@corbits/system-one 0.1.0 → 0.3.0

package/README.md

@@ -1,279 +1,221 @@
 # @corbits/system-one
 
-[![License: LGPL-2.1](https://img.shields.io/badge/license-LGPL--2.1-green.svg)](./LICENSE)
-[![Runtime: Bun](https://img.shields.io/badge/runtime-Bun%201.2%2B-black.svg)](#development)
-
-**Typed decisions from System One (Jev-class) models — as an Interchange
-inference provider, or as a direct `evaluate()` call.**
-
-Ask choice, score, and boolean questions over a state payload. You get
-back per-kind decisions, or a typed fallback when the backend is
-unreachable. Official, gateway, and custom endpoints are config, not
-forked code.
-
-## Contents
-
-- [Why](#why)
-- [Quickstart](#quickstart)
-- [How it works](#how-it-works)
-- [Development](#development)
-- [License](#license)
-
-## Why
-
-Interchange agents and workflows already speak providers. This package
-is the System One adapter for that surface:
-
-- **One provider id.** `SYSTEM_ONE_PROVIDER` is `"corbits-system-one"`
-  — same naming as the other Corbits libraries, not a generic
-  `"system-one"`. Use it in `defineAgent` / workflow inference sources
-  the way you would `"anthropic"`.
-- **Questions on the call.** Pass Jev questions (and optional state)
-  through `providerOptions.systemOne`. The transcript is the default
-  state when you omit it.
-- **Two output shapes.** Direct `evaluate()` returns an
-  `EvaluateResult` or `FallbackResult`. The adapter unwraps the same
-  decisions into Interchange `inference.text.delta` / `inference.usage`
-  events so an agent step can consume them.
-- **Host-owned credentials.** The adapter sends Interchange's bearer
-  sentinel; the harness injects the real key. Peers are
-  `@intx/inference` and `@intx/types` — one copy, the host's.
+Typed choice, score and yes/no decisions about a JSON state from TypeSafe's Jev model, returned as a validated result or a typed fallback. An inference provider for Corbits and Interchange agents: registers as an `@intx/inference` adapter, and also works standalone through `evaluate()`.
 
-## Quickstart
+## Why @corbits/system-one?
 
-Requires [Bun](https://bun.sh/) 1.2+. Peers resolve to the host's
-Interchange copies.
+1. **Typed decisions, not free text.** You send questions with ids; you get back one validated decision per id, with probabilities and confidence. No prompt parsing.
+2. **Failures are data.** A missing key, timeout, HTTP error or bad body returns a `FallbackResult` with a `reason`, so a gate can fail closed without a `try`. Only invalid caller input throws.
+3. **One call, many questions.** Every question in a list goes out in one POST, bounded by a 1.5 s default timeout.
 
-```
-bun add @corbits/system-one
-```
+It evaluates structured state against questions. For open-ended chat completions, use a general inference provider such as [`@corbits/openai-responses`](https://github.com/corbitsdev/corbits-openai-responses).
 
-Shared questions used below:
+## Install
 
-```ts
-const questions = [
-  {
-    id: "route",
-    type: "choice",
-    instructions: "What permission decision does this request warrant?",
-    criteria: { allow: "Low-risk request", deny: "Refuse the request" },
-  },
-  {
-    id: "escalate",
-    type: "boolean",
-    instructions: "Must this request be escalated for human approval?",
-  },
-];
+```bash
+bun add @corbits/system-one @intx/inference@^0.4.0 @intx/types@^0.4.0
 ```
 
-### Direct `evaluate()` — typed result object
+Runs on Bun >= 1.2 or Node >= 24.
+
+## Quickstart
 
-No Interchange runtime. You get a discriminated result: success
-(`fallback: false`) or a typed fallback (`fallback: true`). Boolean
-questions answer as native `noul` (0..1).
+Needs `TYPESAFE_API_KEY` set.
 
 ```ts
 import { evaluate } from "@corbits/system-one";
 
 const result = await evaluate({
   state: { action: "deploy", env: "production" },
-  questions,
-  config: { apiKey: process.env.TYPESAFE_API_KEY },
-});
-```
-
-Success looks like:
-
-```ts
-{
-  fallback: false,
-  backend: "corbits-system-one", // official endpoint; "gateway" | "custom" otherwise
-  modelId: "jev-1.13.0",
-  latencyMs: 412,
-  usage: { inputTokens: 296, outputTokens: 20 },
-  decisions: [
-    {
-      id: "route",
-      type: "choice",
-      choice: "deny",
-      confidence: 0.86,
-      probabilities: { allow: 0.14, deny: 0.86 },
-    },
+  questions: [
     {
       id: "escalate",
-      type: "noul",
-      noul: 0.91,
+      type: "boolean",
+      instructions: "Must this request be escalated for human approval?",
     },
   ],
-}
+});
+
+console.log(result.fallback ? result.reason : result.decisions);
 ```
 
-No key / timeout / HTTP / parse failure looks like:
+On success it prints one decision per question, or the fallback reason on failure:
 
 ```ts
-{
-  fallback: true,
-  reason: "no-key", // or "timeout" | "network" | "http-error" | "parse-error" | "backend-unreachable"
-  latencyMs: 2,
-  backendAttempted: "https://api.typesafe.ai/...",
-  detail: "no API key in config.apiKey, TYPESAFE_API_KEY, or SYSTEM_ONE_API_KEY",
-}
+[{ id: "escalate", type: "noul", noul: 0.91 }];
 ```
 
-Invalid caller input (bad questions, custom endpoint without `url`)
-still **throws** a `SystemOneError` — that is not a fallback.
+Boolean questions answer as `noul`, a probability from 0 to 1 that the answer is yes.
 
-Auth: `config.apiKey`, else `TYPESAFE_API_KEY` (official),
-`AI_GATEWAY_API_KEY` / `VERCEL_OIDC_TOKEN` (gateway), else
-`SYSTEM_ONE_API_KEY`. Endpoint: omit for official (`jev-latest`);
-`{ kind: "gateway" }`; `{ kind: "custom", url }`.
+## Where it fits
 
-### Adapter — Interchange events, same decisions
+[Interchange](https://github.com/faremeter/interchange) runs AI agents as principals (accounts that hold their own identity, permissions and credentials). Corbits packages add what an agent product needs around it.
 
-`createSystemOneAdapter()` is a `ProviderAdapter`. Register
-`"corbits-system-one"`, put questions on the call. The harness
-streams events instead of returning `EvaluateResult`.
+- **Runs in:** the agent sidecar (the runtime next to each agent), or any process. `evaluate()` needs no Interchange runtime.
+- **Plugs into:** the [`@intx/inference`](https://github.com/faremeter/interchange/tree/main/packages/inference) adapter registry, as the adapter for the `corbits-system-one` provider id.
+- **Pairs with:** [`@corbits/openai-responses`](https://github.com/corbitsdev/corbits-openai-responses) and [`@corbits/ollama-adapter`](https://github.com/corbitsdev/corbits-ollama-adapter), the other Corbits inference providers.
 
-```ts
-import { createAgent, defineAgent } from "@intx/agent";
-import {
-  createSystemOneAdapter,
-  SYSTEM_ONE_PROVIDER, // "corbits-system-one"
-} from "@corbits/system-one";
+## Reference
 
-const def = defineAgent({
-  id: "permission-gate",
-  systemPrompt: "Decide whether this request needs human approval.",
-  tools: [],
-  capabilities: [],
-  inference: {
-    sources: [{ provider: SYSTEM_ONE_PROVIDER, model: "jev-latest" }],
-  },
-});
+| Export                            | Description                                                                         |
+| --------------------------------- | ----------------------------------------------------------------------------------- |
+| `evaluate(input, options?)`       | Runs one evaluation. Returns `EvaluateResult`: decisions or a `FallbackResult`.     |
+| `createSystemOneAdapter(config?)` | Returns a `ProviderAdapter` for `runInference`. `config` is an `EvaluateConfig`.    |
+| `createSystemOneAdapterFactory`   | Interchange `AdapterFactory` for `SIDECAR_ADAPTER_MANIFEST`; takes offering quirks. |
+| `SYSTEM_ONE_PROVIDER`             | The `"corbits-system-one"` provider id.                                             |
+| `DEFAULT_TIMEOUT_MS`              | `1500`, the default `timeoutMs`.                                                    |
+| `SystemOneError`                  | Thrown for invalid input or a `custom` endpoint without a `url`.                    |
+| `SystemOneTelemetryEvent`         | Schema and type for events passed to `onTelemetry`.                                 |
+| `EvaluateOptions`, `EvaluateDeps` | Types for `options`: `onTelemetry`, and `deps: { fetch, scheduler }`.               |
 
-const agent = await createAgent(def, {
-  source: {
-    id: SYSTEM_ONE_PROVIDER,
-    provider: SYSTEM_ONE_PROVIDER,
-    model: "jev-latest",
-    apiKey: process.env.TYPESAFE_API_KEY,
-    adapter: createSystemOneAdapter(),
-  },
-});
+`Question`, `QuestionList`, `Decision`, `EvaluateInput`, `EvaluateConfig`, `EndpointConfig`, `EvaluateResult` and `FallbackResult` are exported as arktype schemas and types.
 
-const { reply } = await agent.send("Deploy to production?", {
-  providerOptions: { systemOne: { questions } },
-});
-```
+### Questions
 
-What the adapter emits (what `reply` is assembled from):
+| `type`    | Fields                                                                          | Decision fields                                  |
+| --------- | ------------------------------------------------------------------------------- | ------------------------------------------------ |
+| `choice`  | `instructions`, `criteria` (option name → description or `null`, 1–255 options) | `choice`, `probabilities`, `confidence`          |
+| `score`   | `instructions`, `criteria` (2–10 descriptions)                                  | `score`, `legend`, `probabilities`, `confidence` |
+| `boolean` | `instructions`, optional `criteria: { true?, false? }`                          | `noul`                                           |
+| `noul`    | Same as `boolean`                                                               | `noul`                                           |
 
-```ts
-[
-  {
-    type: "inference.text.delta",
-    data: {
-      index: 0,
-      token:
-        '{"id":"route","type":"choice","choice":"deny","confidence":0.86,"probabilities":{"allow":0.14,"deny":0.86}}',
-    },
-  },
-  {
-    type: "inference.text.delta",
-    data: {
-      index: 1,
-      token: '{"id":"escalate","type":"noul","noul":0.91}',
-    },
-  },
-  {
-    type: "inference.usage",
-    data: {
-      usage: {
-        input: 296,
-        output: 20,
-        cacheRead: 0,
-        cacheWrite: 0,
-        thinking: 0,
-      },
-    },
-  },
-];
-```
+Every question has an `id`, unique within the list.
+
+### Config
+
+`input.config` for `evaluate`, or the argument to `createSystemOneAdapter`:
+
+| Field       | Type             | Default                | Description                                                                      |
+| ----------- | ---------------- | ---------------------- | -------------------------------------------------------------------------------- |
+| `endpoint`  | `EndpointConfig` | `{ kind: "official" }` | `official`, `gateway`, or `custom` with a `url`. Each takes an optional `model`. |
+| `timeoutMs` | `number`         | `1500`                 | Bound for the whole round trip.                                                  |
+| `apiKey`    | `string`         | from the environment   | Overrides the environment key.                                                   |
 
-`JSON.parse` each `token` and you have the same decision objects as
-`result.decisions`. There is no `fallback` flag on this path: a bad
-wire body is a `ProtocolMismatchError`; auth/retry stay with the
-harness (`retry-after` is surfaced for 429/529).
+### Endpoints and keys
 
-### Workflow step
+| `kind`     | URL                                                  | Default model     | Key from the environment                       |
+| ---------- | ---------------------------------------------------- | ----------------- | ---------------------------------------------- |
+| `official` | `https://api.typesafe.ai/v1/systemone`               | `jev-latest`      | `TYPESAFE_API_KEY`                             |
+| `gateway`  | `https://ai-gateway.vercel.sh/typesafe/v1/systemone` | `typesafe-ai/jev` | `AI_GATEWAY_API_KEY`, then `VERCEL_OIDC_TOKEN` |
+| `custom`   | `url`                                                | `typesafe-ai/jev` | `SYSTEM_ONE_API_KEY`                           |
 
-Same provider and options bag:
+`SYSTEM_ONE_API_KEY` is also a supported alias on every endpoint, read after the endpoint's own key.
+
+### Fallback reasons
+
+| `reason`      | When                                                          |
+| ------------- | ------------------------------------------------------------- |
+| `no-key`      | No key in `apiKey` or the environment. No request is sent.    |
+| `timeout`     | The round trip, including the body read, exceeds `timeoutMs`. |
+| `network`     | The request fails before a response.                          |
+| `http-error`  | Non-2xx response. `httpStatus` holds the status.              |
+| `parse-error` | The body is not JSON or fails validation.                     |
+
+`detail` carries the underlying message.
+
+## Using with Interchange
+
+Register the adapter under `SYSTEM_ONE_PROVIDER` and pass questions per call in `providerOptions.systemOne` (`{ state?, questions? }`). Without `state`, the adapter sends the transcript text as state. Without `questions`, it asks one boolean question with id `response`.
 
 ```ts
-import { defineWorkflow } from "@intx/workflow";
+import { createDependencies, runInference } from "@intx/inference";
 import {
   createSystemOneAdapter,
   SYSTEM_ONE_PROVIDER,
+  type QuestionList,
 } from "@corbits/system-one";
 
-export const refundGate = defineWorkflow({
-  id: "refund-gate",
-  steps: [
+const deps = createDependencies({
+  has: (provider) => provider === SYSTEM_ONE_PROVIDER,
+  resolve: () => createSystemOneAdapter(),
+});
+
+const questions = [
+  {
+    id: "escalate",
+    type: "boolean",
+    instructions: "Must this request be escalated for human approval?",
+  },
+] satisfies QuestionList;
+
+let seq = 0;
+for await (const event of runInference({
+  deps,
+  source: {
+    id: "system-one",
+    provider: SYSTEM_ONE_PROVIDER,
+    baseURL: "https://api.typesafe.ai/v1/systemone",
+    credentialId: "TYPESAFE_API_KEY",
+    model: "jev-latest",
+  },
+  turns: [
     {
-      id: "decide",
-      inference: {
-        source: {
-          provider: SYSTEM_ONE_PROVIDER,
-          model: "jev-latest",
-          adapter: createSystemOneAdapter(),
-        },
-        providerOptions: {
-          systemOne: {
-            state: { amount: 48, priorRefunds: 1 },
-            questions: [
-              {
-                id: "approve",
-                type: "boolean",
-                instructions: "Approve this refund without review?",
-              },
-            ],
-          },
-        },
-      },
+      role: "user",
+      timestamp: Date.now(),
+      content: [{ type: "text", text: "Deploy to production?" }],
     },
   ],
-});
+  inferenceOptions: { providerOptions: { systemOne: { questions } } },
+  nextSeq: () => seq++,
+  readMaterial: (id) => {
+    const secret = process.env[id];
+    if (secret === undefined) throw new Error(`${id} is not set`);
+    return { secret };
+  },
+})) {
+  if (event.type === "inference.text.delta")
+    console.log(JSON.parse(event.data.token));
+}
 ```
 
-The step's inference output is the same event list: one text delta
-whose token is `{"id":"approve","type":"noul","noul":0.2}`, then
-usage.
-
-## How it works
+The adapter emits one `inference.text.delta` per decision, whose `token` is the decision as JSON, then an `inference.usage` event. The harness supplies the credential through `readMaterial` and owns retries. A malformed response body is a `ProtocolMismatchError`, not a fallback.
 
-- **Wire.** Live Jev contract ([docs.typesafe.ai](https://docs.typesafe.ai)):
-  `state` is string | object | array; questions go out as an id-keyed
-  map; answers come back the same way.
-- **Adapter.** Transcript → evaluation state; each decision →
-  `inference.text.delta`; token counts → `inference.usage`.
-- **Schemas.** Every trust boundary is arktype (`src/schemas.ts`).
-  Confidence is narrowed, not clamped. Public surface is
-  `src/index.ts` only.
-- **Telemetry.** Direct `evaluate()` records `evaluate.start` /
-  `.success` / `.fallback` in-memory (`drainTelemetryEvents`). No keys
-  in events.
+### Manifest factory
 
-## Development
+`createSystemOneAdapterFactory(source, quirks?)` is an Interchange `AdapterFactory`, so a stock sidecar loads it from `SIDECAR_ADAPTER_MANIFEST` with no custom code:
 
+```json
+[
+  {
+    "provider": "corbits-system-one",
+    "specifier": "@corbits/system-one",
+    "export": "createSystemOneAdapterFactory"
+  }
+]
 ```
-bun install
-bun run check   # typecheck + lint + format:check + test
+
+The hub offering's `quirks` are validated and all optional:
+
+```json
+{
+  "endpoint": {
+    "kind": "custom",
+    "url": "https://opencode.ai/zen/v1/systemone"
+  },
+  "model": "jev-1.13",
+  "questions": [{ "type": "boolean", "id": "gate", "instructions": "Allow?" }],
+  "state": {}
+}
 ```
 
-Compiled `dist/` is built with `tsc -p tsconfig.build.json` (no
-bundler) and ships on npm; `prepack` rebuilds so every pack/publish
-carries fresh output.
+`questions` and `state` are per-call defaults; `providerOptions.systemOne` on a call wins field by field. A top-level `model` applies when `endpoint` sets none. Unknown keys throw. The adapter sends the bearer sentinel and the harness injects the offering's credential.
+
+| Gateway            | `endpoint`                                                       | `model`                       |
+| ------------------ | ---------------------------------------------------------------- | ----------------------------- |
+| Official (default) | omit, or `{"kind":"official"}`                                   | `jev-latest`                  |
+| Vercel AI Gateway  | `{"kind":"gateway"}`                                             | `typesafe-ai/jev`             |
+| OpenCode Zen       | `{"kind":"custom","url":"https://opencode.ai/zen/v1/systemone"}` | `jev-1.13` or `jev-1.13-free` |
+
+## Upgrading from 0.1
+
+- `HttpError`, `NetworkError` and `TimeoutError` are removed. Transport failures return a `FallbackResult`.
+- A 2xx body that is not JSON is `parse-error` (was `network`). A timeout during the body read is `timeout`.
+- `recordTelemetryEvent` and `drainTelemetryEvents` are removed. Pass `evaluate(input, { onTelemetry })`.
+- Wire helpers, quirks presets, `JsonRecord`, `Confidence` and the env-var name constants are no longer exported.
+- A `custom` endpoint without a `model` sends `typesafe-ai/jev`.
+- Peers are `@intx/inference` and `@intx/types` `^0.4.0`.
+- Environment variables are unchanged, including `SYSTEM_ONE_API_KEY`.
 
 ## License
 
-LGPL-2.1-only.
+[LGPL-2.1-only](https://github.com/corbitsdev/corbits-system-one/blob/main/LICENSE)

package/dist/adapter.d.ts

@@ -1,12 +1,11 @@
-import { type ProviderAdapter } from "@intx/inference";
+import { type AdapterFactory, type ProviderAdapter } from "@intx/inference";
 import { type EvaluateConfig } from "./schemas.js";
 /** Provider id this package serves. */
 export declare const SYSTEM_ONE_PROVIDER = "corbits-system-one";
+export declare function createSystemOneAdapter(config?: EvaluateConfig): ProviderAdapter;
 /**
- * Builds the Interchange `ProviderAdapter` for System One against the
- * host's single copy of `@intx/inference` (peer dependency, never vendored).
- * The optional `config` pins the endpoint (official by default, gateway, or
- * a custom URL) and the per-call model default; the inference call's own
- * `model` argument wins for the request body.
+ * Interchange `AdapterFactory` for `SIDECAR_ADAPTER_MANIFEST`: validates the
+ * offering's `quirks` and reuses `createSystemOneAdapter`. A top-level
+ * `model` fills the endpoint's model when the endpoint sets none.
  */
-export declare function createSystemOneAdapter(config?: EvaluateConfig): ProviderAdapter;
+export declare const createSystemOneAdapterFactory: AdapterFactory;

package/dist/adapter.js

@@ -1,7 +1,7 @@
 import { type } from "arktype";
 import { BEARER_CREDENTIAL_SENTINEL, ProtocolMismatchError, } from "@intx/inference";
 import { resolveEndpoint } from "./config.js";
-import { Decision, toDecision, toWireQuestions, WireResponseBody, QuestionList, State, } from "./schemas.js";
+import { Decision, toDecision, toWireQuestions, WireResponseBody, EndpointConfig, QuestionList, State, } from "./schemas.js";
 // ---------------------------------------------------------------------------
 // Adapter
 // ---------------------------------------------------------------------------
@@ -100,7 +100,7 @@ function parseDecisions(body, provider) {
             throw new ProtocolMismatchError(`${provider} parseJSONResponse: ${cause instanceof Error ? cause.message : String(cause)}`, parsed);
         }
     });
-    return { decisions, usage: envelope.usage };
+    return { decisions, model: envelope.model, usage: envelope.usage };
 }
 /**
  * Builds the Interchange `ProviderAdapter` for System One against the
@@ -109,12 +109,12 @@ function parseDecisions(body, provider) {
  * a custom URL) and the per-call model default; the inference call's own
  * `model` argument wins for the request body.
  */
-export function createSystemOneAdapter(config) {
+function createSystemOneProviderAdapter(config, source) {
     const endpoint = resolveEndpoint(config?.endpoint);
-    const source = {
+    const usageSource = source ?? {
         sourceId: SYSTEM_ONE_PROVIDER,
         provider: SYSTEM_ONE_PROVIDER,
-        model: endpoint.model ?? "unknown",
+        model: endpoint.model,
     };
     const buildRequest = (messages, model, options) => {
         let state = { transcript: transcriptText(messages) };
@@ -130,8 +130,7 @@ export function createSystemOneAdapter(config) {
             if (overrides.questions !== undefined)
                 questions = overrides.questions;
         }
-        const requestModel = model || endpoint.model || "unknown";
-        source.model = requestModel;
+        const requestModel = model || endpoint.model;
         const headers = {
             "content-type": "application/json",
             accept: "application/json",
@@ -148,7 +147,7 @@ export function createSystemOneAdapter(config) {
         };
     };
     const parseJSONResponse = (responseBody) => {
-        const { decisions, usage } = parseDecisions(responseBody, SYSTEM_ONE_PROVIDER);
+        const { decisions, model, usage } = parseDecisions(responseBody, SYSTEM_ONE_PROVIDER);
         const events = [];
         let index = 0;
         for (const decision of decisions) {
@@ -163,7 +162,13 @@ export function createSystemOneAdapter(config) {
         events.push({
             type: "inference.usage",
             seq: 0,
-            data: { usage: toTokenUsage(usage), source: { ...source } },
+            data: {
+                usage: toTokenUsage(usage),
+                source: {
+                    ...usageSource,
+                    model: model ?? usageSource.model,
+                },
+            },
         });
         return events;
     };
@@ -191,3 +196,57 @@ export function createSystemOneAdapter(config) {
         extractRetryAfterMs,
     };
 }
+export function createSystemOneAdapter(config) {
+    return createSystemOneProviderAdapter(config);
+}
+// Deployment quirks a hub offering carries for this provider. `questions`
+// and `state` are per-call defaults: a call's own `providerOptions.systemOne`
+// wins field by field.
+const SystemOneFactoryQuirks = type({
+    "endpoint?": EndpointConfig,
+    "model?": "string",
+    "questions?": QuestionList,
+    "state?": State,
+    "+": "reject",
+});
+/**
+ * Interchange `AdapterFactory` for `SIDECAR_ADAPTER_MANIFEST`: validates the
+ * offering's `quirks` and reuses `createSystemOneAdapter`. A top-level
+ * `model` fills the endpoint's model when the endpoint sets none.
+ */
+export const createSystemOneAdapterFactory = (source, quirks) => {
+    const parsed = SystemOneFactoryQuirks(quirks ?? {});
+    if (parsed instanceof type.errors) {
+        throw new Error(`${SYSTEM_ONE_PROVIDER} adapter: invalid quirks: ${parsed.summary}`);
+    }
+    const endpoint = {
+        kind: "official",
+        ...parsed.endpoint,
+    };
+    if (parsed.model !== undefined && endpoint.model === undefined) {
+        endpoint.model = parsed.model;
+    }
+    const adapter = createSystemOneProviderAdapter({ endpoint }, source);
+    const defaults = {
+        ...(parsed.state !== undefined && { state: parsed.state }),
+        ...(parsed.questions !== undefined && { questions: parsed.questions }),
+    };
+    if (Object.keys(defaults).length === 0)
+        return adapter;
+    return {
+        ...adapter,
+        buildRequest: (messages, model, options) => {
+            const raw = options.providerOptions?.["systemOne"];
+            const call = raw === undefined ? {} : raw;
+            return adapter.buildRequest(messages, model, {
+                ...options,
+                providerOptions: {
+                    ...options.providerOptions,
+                    systemOne: typeof call === "object" && call !== null
+                        ? { ...defaults, ...call }
+                        : call,
+                },
+            });
+        },
+    };
+};

package/dist/client.d.ts

@@ -1,8 +1,11 @@
+import { type Dependencies } from "@intx/inference";
 /** Options for one evaluation POST: timeout and auth, resolved by `evaluate`. */
 export type PostEvaluateOptions = {
     timeoutMs?: number;
     apiKey?: string;
 };
+/** Transport dependencies: the `fetch` to POST with and the timeout scheduler. */
+export type EvaluateDeps = Pick<Dependencies, "fetch" | "scheduler">;
 /** The decoded JSON body of a 2xx evaluation response, with its latency. */
 export type PostEvaluateResponse = {
     data: unknown;
@@ -12,10 +15,12 @@ export type PostEvaluateResponse = {
 /**
  * POSTs an evaluation payload and returns the decoded JSON body. Sends
  * `Authorization: Bearer <apiKey>` only when a key is present; aborts the
- * exchange when `timeoutMs` elapses. A `timeoutMs` that is not a finite
- * number >= 0 falls back to `DEFAULT_TIMEOUT_MS`. Throws `TimeoutError` on
- * timeout, `HttpError` (status only, never the body) on non-2xx, and
- * `NetworkError` when no HTTP exchange completes or the 2xx body is not
- * valid JSON.
+ * exchange when `timeoutMs` elapses on `deps.scheduler`. A `timeoutMs`
+ * that is not a finite number >= 0 falls back to `DEFAULT_TIMEOUT_MS`.
+ * Throws a `TransportError` carrying a `timeout` classification on
+ * timeout, a `classifyHTTPError` classification (status only, never the
+ * body) on non-2xx, a `classifyNetworkError` classification when no HTTP
+ * exchange completes, and a `classifyProtocolMismatch` classification when
+ * the 2xx body is not valid JSON.
  */
-export declare function postEvaluate(url: string, body: unknown, options: PostEvaluateOptions): Promise<PostEvaluateResponse>;
+export declare function postEvaluate(url: string, body: unknown, options: PostEvaluateOptions, deps: EvaluateDeps): Promise<PostEvaluateResponse>;