@intx/inference-discovery-openai 0.2.2 → 0.3.0

package/README.md

@@ -10,8 +10,8 @@ is organised in two layers:
 - `deployments/` — concrete deployments built on the protocol
   layer. Each deployment names a provider, lists its models,
   declares its auth and redaction policy, and (where needed)
-  overrides reasoning extraction. Today the only deployment is
-  OpenCode Zen.
+  overrides reasoning extraction. Three deployments ship today: the
+  OpenCode Zen relay, first-party OpenAI, and first-party xAI.
 
 See [`@intx/inference-discovery`](../inference-discovery/README.md)
 for the runtime, the plug-in contract, and the `discover` CLI.
@@ -30,41 +30,98 @@ re-run unchanged against it.
 import { createOpencodeZenPlugin } from "@intx/inference-discovery-openai";
 
 const plugin = createOpencodeZenPlugin({
-  apiKey: process.env.OPENAI_API_KEY,
-  baseUrl: process.env.OPENAI_BASE_URL,
+  apiKey: process.env.OPENCODE_API_KEY,
+  baseUrl: process.env.OPENCODE_BASE_URL,
 });
 // Hand off to runCapture from @intx/inference-discovery.
 ```
 
-Models: `kimi-k2.6`, `glm-5.1`, `deepseek-v4-pro`, `qwen3.6-plus`,
-`mimo-v2-omni`.
+Models: `kimi-k2.6`, `kimi-k2.7-code`, `kimi-k3`, `glm-5.2`,
+`deepseek-v4-pro`, `deepseek-v4-flash`, `qwen3.7-plus`, `mimo-v2.5`,
+`gpt-5.4-mini`.
 
 For the per-model, per-capability behaviour observed at capture
 time — including the discrepancies between vendor documentation
 and the actual wire bytes — see
-[`docs/OPENCODE_DISCOVERY.md`](../../docs/OPENCODE_DISCOVERY.md).
-The matrix entries for this deployment live in `SUPPORT_MATRIX`;
-two vision entries are marked `refused` and `http-error` and so
-produce no fixtures.
-
-### Reasoning trace extraction
-
-OpenCode Zen routes `kimi-k2.6` between two upstream backends that
-emit reasoning content under different field paths. The deployment
-ships a reasoning extractor that probes the known paths and records
-which one held the non-empty value. For non-streaming reasoning
-captures the runner writes the result to `reasoning-trace.json`
-next to the response so a later routing change is detectable from
-the fixtures alone; streaming reasoning captures do not get the
-sidecar (the runner does not parse SSE bodies), and the routing
-signal lives in the captured event stream itself.
+[`docs/discovery.md`](./docs/discovery.md).
+The matrix entries for this deployment live in `SUPPORT_MATRIX`.
+`deepseek-v4-pro` vision-input is `http-error` and produces no
+fixture; other non-vision models simply omit vision rows.
 
 ### Environment
 
-| Variable          | Purpose                                                      |
-| ----------------- | ------------------------------------------------------------ |
-| `OPENAI_API_KEY`  | Sent as `Authorization: Bearer <key>`. Redacted in fixtures. |
-| `OPENAI_BASE_URL` | Relay base URL (e.g. `https://opencode.ai/zen/v1`).          |
+| Variable            | Purpose                                                      |
+| ------------------- | ------------------------------------------------------------ |
+| `OPENCODE_API_KEY`  | Sent as `Authorization: Bearer <key>`. Redacted in fixtures. |
+| `OPENCODE_BASE_URL` | Relay base URL (e.g. `https://opencode.ai/zen/v1`).          |
+
+## OpenAI
+
+The `openai` deployment probes first-party `api.openai.com` directly,
+under provider name `openai` (distinct from `opencode-zen`, though both
+write sessions into this package's `sessions/` tree). The base URL is fixed
+to `https://api.openai.com/v1`; the deployment reads only `OPENAI_API_KEY`.
+
+```ts
+import { createOpenAIPlugin } from "@intx/inference-discovery-openai";
+
+const plugin = createOpenAIPlugin({ apiKey: process.env.OPENAI_API_KEY });
+// Hand off to runCapture from @intx/inference-discovery.
+```
+
+Models: `gpt-5.5`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`.
+
+Each first-party model captures `plain-text`, `function-calling`,
+`function-calling-multi-turn`, `vision-input`, `document-input`, and
+`structured-output` (plus the streaming variants the OpenAI-protocol body
+builder emits). `reasoning-content` is marked `unsupported`: first-party
+`api.openai.com` Chat Completions responses carry no reasoning field for
+the gpt-5 series (OpenAI surfaces reasoning only via the Responses API,
+which this plug-in does not probe). The `function-calling-multi-turn`,
+`vision-input`, and `document-input` streaming variants carry no rows
+because the body builder does not build them — a rig gap, not a provider
+limitation.
+
+### Environment
+
+| Variable         | Purpose                                                      |
+| ---------------- | ------------------------------------------------------------ |
+| `OPENAI_API_KEY` | Sent as `Authorization: Bearer <key>`. Redacted in fixtures. |
+
+## xAI
+
+The `xai` deployment probes first-party `api.x.ai` directly, under provider
+name `xai` (distinct from `openai` and `opencode-zen`, though all three write
+sessions into this package's `sessions/` tree). The base URL is fixed to
+`https://api.x.ai/v1`; the deployment reads only `XAI_API_KEY`.
+
+```ts
+import { createXaiPlugin } from "@intx/inference-discovery-openai";
+
+const plugin = createXaiPlugin({ apiKey: process.env.XAI_API_KEY });
+// Hand off to runCapture from @intx/inference-discovery.
+```
+
+Models: `grok-4.20-0309-non-reasoning`, `grok-4.20-0309-reasoning`, `grok-4.3`,
+`grok-4.5`, `grok-4.6`, `grok-build-0.1`.
+
+Each model captures `plain-text`, `function-calling`,
+`function-calling-multi-turn`, `vision-input`, and `structured-output` (plus
+the streaming variants the OpenAI-protocol body builder emits).
+`reasoning-content` captures on every model except
+`grok-4.20-0309-non-reasoning`, xAI's explicit non-reasoning variant, which
+returns text with no `reasoning_content` field and so is marked `unsupported`.
+`structured-output-refusal-streaming` is `misled`: under a strict `json_schema`
+plus a declining prompt, the model streams schema-conformant JSON carrying a
+textual decline rather than a `delta.refusal` field. `document-input` is
+`http-error`: xAI Chat Completions rejects file content parts and directs
+callers to the Responses API, which this plug-in does not probe.
+
+### Environment
+
+| Variable      | Purpose                                                      |
+| ------------- | ------------------------------------------------------------ |
+| `XAI_API_KEY` | Sent as `Authorization: Bearer <key>`. Redacted in fixtures. |
 
 ## Adding a new deployment
 

package/dist/deployments/openai.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderPlugin } from "@intx/inference-discovery";
+export interface CreateOpenAIPluginOpts {
+    apiKey: string;
+}
+export declare function createOpenAIPlugin(opts: CreateOpenAIPluginOpts): ProviderPlugin;

package/dist/deployments/openai.js

@@ -0,0 +1,53 @@
+import { buildAuthHeaders } from "../protocol/auth.js";
+import { createOpenaiIterator } from "../protocol/iterator.js";
+const PROVIDER_NAME = "openai";
+// First-party OpenAI Chat Completions endpoint. Unlike the OpenCode Zen relay,
+// there is no configurable base URL: the deployment reads only OPENAI_API_KEY
+// and always talks to api.openai.com.
+const OPENAI_BASE_URL = "https://api.openai.com/v1";
+const OPENAI_MODELS = [
+    "gpt-5.5",
+    "gpt-5.6-sol",
+    "gpt-5.6-terra",
+    "gpt-5.6-luna",
+    "gpt-5",
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-5.1",
+    "gpt-5.2",
+    "gpt-5.4",
+    "gpt-5.4-mini",
+    "gpt-5.4-nano",
+    "o1",
+    "o3",
+    "o3-mini",
+    "o4-mini",
+    "gpt-4",
+    "gpt-4-turbo",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-4o",
+    "gpt-4o-mini",
+];
+const REDACT_REQUEST_HEADERS = ["authorization"];
+const REDACT_RESPONSE_HEADERS = [
+    "set-cookie",
+    "x-request-id",
+    "openai-organization",
+    "openai-project",
+];
+// A live gpt-5.5 capture confirmed that first-party api.openai.com Chat
+// Completions responses carry no reasoning or reasoning_content field: OpenAI
+// surfaces reasoning only via the Responses API, not this Chat Completions wire.
+export function createOpenAIPlugin(opts) {
+    const { apiKey } = opts;
+    return {
+        name: PROVIDER_NAME,
+        models: OPENAI_MODELS,
+        redactRequestHeaders: REDACT_REQUEST_HEADERS,
+        redactResponseHeaders: REDACT_RESPONSE_HEADERS,
+        buildAuthHeaders: () => buildAuthHeaders(apiKey),
+        iterateCaptureSteps: createOpenaiIterator(OPENAI_BASE_URL),
+    };
+}

package/dist/deployments/opencode-zen.d.ts

@@ -1,9 +1,4 @@
 import type { ProviderPlugin } from "@intx/inference-discovery";
-export interface ReasoningTrace {
-    fieldPath: string;
-    sample: unknown;
-}
-export declare function extractReasoningTrace(parsed: unknown): ReasoningTrace | null;
 export interface CreateOpencodeZenPluginOpts {
     apiKey: string;
     baseUrl: string;

package/dist/deployments/opencode-zen.js

@@ -3,65 +3,20 @@ import { createOpenaiIterator } from "../protocol/iterator.js";
 const PROVIDER_NAME = "opencode-zen";
 const OPENCODE_ZEN_MODELS = [
     "kimi-k2.6",
-    "glm-5.1",
+    "kimi-k2.7-code",
+    "kimi-k3",
+    "glm-5.2",
     "deepseek-v4-pro",
-    "qwen3.6-plus",
-    "mimo-v2-omni",
+    "deepseek-v4-flash",
+    "qwen3.7-plus",
+    "mimo-v2.5",
+    "gpt-5.4-mini",
 ];
 const REDACT_REQUEST_HEADERS = ["authorization"];
 const REDACT_RESPONSE_HEADERS = [
     "set-cookie",
     "x-request-id",
 ];
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function lookupPath(value, path) {
-    let cursor = value;
-    for (const segment of path) {
-        if (cursor === null || cursor === undefined)
-            return undefined;
-        if (typeof segment === "number") {
-            if (!Array.isArray(cursor))
-                return undefined;
-            cursor = cursor[segment];
-        }
-        else {
-            if (!isRecord(cursor))
-                return undefined;
-            cursor = cursor[segment];
-        }
-    }
-    return cursor;
-}
-function isNonEmpty(value) {
-    if (value === null || value === undefined)
-        return false;
-    if (typeof value === "string")
-        return value.length > 0;
-    if (Array.isArray(value))
-        return value.length > 0;
-    if (typeof value === "object")
-        return Object.keys(value).length > 0;
-    return true;
-}
-// kimi-k2.6 silently routes between two upstream backends that emit
-// reasoning under different field paths. Recording which path a given
-// capture hit is the cheapest way to detect routing changes later.
-const REASONING_FIELD_PATHS = [
-    ["choices", 0, "message", "reasoning_content"],
-    ["choices", 0, "message", "reasoning"],
-    ["choices", 0, "message", "reasoning_details"],
-];
-export function extractReasoningTrace(parsed) {
-    for (const path of REASONING_FIELD_PATHS) {
-        const value = lookupPath(parsed, path);
-        if (isNonEmpty(value)) {
-            return { fieldPath: path.join("."), sample: value };
-        }
-    }
-    return null;
-}
 export function createOpencodeZenPlugin(opts) {
     const { apiKey, baseUrl } = opts;
     return {
@@ -70,7 +25,6 @@ export function createOpencodeZenPlugin(opts) {
         redactRequestHeaders: REDACT_REQUEST_HEADERS,
         redactResponseHeaders: REDACT_RESPONSE_HEADERS,
         buildAuthHeaders: () => buildAuthHeaders(apiKey),
-        extractReasoningTrace,
         iterateCaptureSteps: createOpenaiIterator(baseUrl),
     };
 }

package/dist/deployments/xai.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderPlugin } from "@intx/inference-discovery";
+export interface CreateXaiPluginOpts {
+    apiKey: string;
+}
+export declare function createXaiPlugin(opts: CreateXaiPluginOpts): ProviderPlugin;

package/dist/deployments/xai.js

@@ -0,0 +1,35 @@
+import { buildAuthHeaders } from "../protocol/auth.js";
+import { createOpenaiIterator } from "../protocol/iterator.js";
+const PROVIDER_NAME = "xai";
+// First-party xAI Chat Completions endpoint. Like the first-party OpenAI
+// deployment and unlike the OpenCode Zen relay, there is no configurable base
+// URL: the deployment reads only XAI_API_KEY and always talks to api.x.ai. This
+// string must stay byte-identical to CATALOG_TO_BASE_URL["xai"] in
+// @intx/inference-discovery's provider-adapter, which stamps the manifest's
+// source.baseURL; the request URL comes from here and the recorded provenance
+// comes from there, and nothing cross-checks them at capture time.
+const XAI_BASE_URL = "https://api.x.ai/v1";
+const XAI_MODELS = [
+    "grok-4.20-0309-non-reasoning",
+    "grok-4.20-0309-reasoning",
+    "grok-4.3",
+    "grok-4.5",
+    "grok-4.6",
+    "grok-build-0.1",
+];
+const REDACT_REQUEST_HEADERS = ["authorization"];
+const REDACT_RESPONSE_HEADERS = [
+    "set-cookie",
+    "x-request-id",
+];
+export function createXaiPlugin(opts) {
+    const { apiKey } = opts;
+    return {
+        name: PROVIDER_NAME,
+        models: XAI_MODELS,
+        redactRequestHeaders: REDACT_REQUEST_HEADERS,
+        redactResponseHeaders: REDACT_RESPONSE_HEADERS,
+        buildAuthHeaders: () => buildAuthHeaders(apiKey),
+        iterateCaptureSteps: createOpenaiIterator(XAI_BASE_URL),
+    };
+}

package/dist/index.d.ts

@@ -1 +1,3 @@
-export { createOpencodeZenPlugin, extractReasoningTrace, type CreateOpencodeZenPluginOpts, type ReasoningTrace, } from "./deployments/opencode-zen.js";
+export { createOpencodeZenPlugin, type CreateOpencodeZenPluginOpts, } from "./deployments/opencode-zen.js";
+export { createOpenAIPlugin, type CreateOpenAIPluginOpts, } from "./deployments/openai.js";
+export { createXaiPlugin, type CreateXaiPluginOpts } from "./deployments/xai.js";

package/dist/index.js

@@ -1 +1,3 @@
-export { createOpencodeZenPlugin, extractReasoningTrace, } from "./deployments/opencode-zen.js";
+export { createOpencodeZenPlugin, } from "./deployments/opencode-zen.js";
+export { createOpenAIPlugin, } from "./deployments/openai.js";
+export { createXaiPlugin } from "./deployments/xai.js";

package/dist/protocol/body.d.ts

@@ -20,6 +20,7 @@ export interface ChatCompletionsRequest {
     stream?: boolean;
     tools?: unknown[];
     response_format?: unknown;
+    reasoning_effort?: "none";
 }
 export declare function buildMultiTurnTurn1Body(opts: {
     model: string;

package/dist/protocol/body.js

@@ -1,5 +1,19 @@
 import { readFileSync } from "node:fs";
-import { resolveMediaPath, } from "@intx/inference-discovery/catalog";
+import { basename } from "node:path";
+import { CapabilityNotBuildableError, resolveMediaPath, } from "@intx/inference-discovery/catalog";
+// gpt-5.6 Chat Completions rejects function tools unless reasoning_effort
+// is explicitly "none" (use Responses API for reasoned tool use). Add a
+// model here when tool calls fail with the reasoning_effort invalid_request.
+const TOOL_CALL_REASONING_NONE_MODELS = new Set([
+    "gpt-5.6-sol",
+    "gpt-5.6-terra",
+    "gpt-5.6-luna",
+]);
+function applyToolCallingEffort(body, model) {
+    if (TOOL_CALL_REASONING_NONE_MODELS.has(model)) {
+        body.reasoning_effort = "none";
+    }
+}
 function mimeTypeFor(ref) {
     if (ref.kind === "image")
         return "image/jpeg";
@@ -40,18 +54,22 @@ function buildPlainTextBody(model, intent, stream) {
     return body;
 }
 function buildFunctionCallingBody(model, intent) {
-    return {
+    const body = {
         model,
         messages: [{ role: "user", content: intent.prompt }],
         tools: buildToolDecl(intent),
     };
+    applyToolCallingEffort(body, model);
+    return body;
 }
 export function buildMultiTurnTurn1Body(opts) {
-    return {
+    const body = {
         model: opts.model,
         messages: [{ role: "user", content: opts.intent.prompt }],
         tools: buildToolDecl(opts.intent),
     };
+    applyToolCallingEffort(body, opts.model);
+    return body;
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -122,6 +140,7 @@ export function buildMultiTurnTurn2Body(opts) {
     if (tools !== undefined) {
         body.tools = tools;
     }
+    applyToolCallingEffort(body, opts.model);
     return body;
 }
 function buildReasoningBody(model, intent, stream) {
@@ -169,25 +188,44 @@ function buildStructuredOutputBody(model, intent, stream) {
         body.stream = true;
     return body;
 }
-function buildVisionBody(model, intent) {
+// Shared skeleton for Chat Completions multimodal user turns: text
+// prompt plus one typed part per media ref. Vision and document only
+// differ in the expected kind and the part shape.
+function buildMediaInputBody(model, intent, capability, expectedKind, toPart) {
     if (!intent.media || intent.media.length === 0) {
-        throw new Error("intent has no media but vision-input requires it");
+        throw new Error(`intent has no media but ${capability} requires it`);
     }
     const parts = [{ type: "text", text: intent.prompt }];
     for (const ref of intent.media) {
-        if (ref.kind !== "image") {
-            throw new Error(`vision-input only accepts image media, got: ${ref.kind}`);
+        if (ref.kind !== expectedKind) {
+            throw new Error(`${capability} only accepts ${expectedKind} media, got: ${ref.kind}`);
         }
-        parts.push({
-            type: "image_url",
-            image_url: { url: readMediaDataUri(ref) },
-        });
+        parts.push(toPart(ref));
     }
     return {
         model,
         messages: [{ role: "user", content: parts }],
     };
 }
+function imagePart(ref) {
+    return {
+        type: "image_url",
+        image_url: { url: readMediaDataUri(ref) },
+    };
+}
+function documentPart(ref) {
+    const filename = basename(ref.path);
+    if (filename.length === 0) {
+        throw new Error("document-input media path has an empty basename; Chat Completions requires filename");
+    }
+    return {
+        type: "file",
+        file: {
+            filename,
+            file_data: readMediaDataUri(ref),
+        },
+    };
+}
 export function buildRequestBody(args) {
     const { model, capability, intent } = args;
     switch (capability) {
@@ -204,12 +242,15 @@ export function buildRequestBody(args) {
         case "reasoning-content-streaming":
             return buildReasoningBody(model, intent, true);
         case "vision-input":
-            return buildVisionBody(model, intent);
+            return buildMediaInputBody(model, intent, "vision-input", "image", imagePart);
+        case "document-input":
+            return buildMediaInputBody(model, intent, "document-input", "document", documentPart);
         case "structured-output":
             return buildStructuredOutputBody(model, intent, false);
         case "structured-output-streaming":
+        case "structured-output-refusal-streaming":
             return buildStructuredOutputBody(model, intent, true);
         default:
-            throw new Error(`OpenAI protocol: capability "${capability}" not implemented`);
+            throw new CapabilityNotBuildableError(capability, `OpenAI protocol: capability "${capability}" not implemented`);
     }
 }

package/dist/protocol/iterator.js

@@ -12,7 +12,6 @@ export function createOpenaiIterator(baseUrl) {
             const turn1 = buildMultiTurnTurn1Body({ model, intent });
             const turn1Response = yield {
                 kind: "json",
-                subdir: "turn-1",
                 url,
                 body: turn1,
             };
@@ -24,7 +23,6 @@ export function createOpenaiIterator(baseUrl) {
             });
             yield {
                 kind: "json",
-                subdir: "turn-2",
                 url,
                 body: turn2,
             };
@@ -32,7 +30,6 @@ export function createOpenaiIterator(baseUrl) {
         }
         yield {
             kind: "json",
-            subdir: null,
             url,
             body: buildRequestBody({ model, capability, intent }),
         };

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@intx/inference-discovery-openai",
-  "version": "0.2.2",
+  "description": "OpenAI-protocol provider plug-in for the inference discovery rig",
+  "version": "0.3.0",
   "license": "LGPL-2.1-only",
   "type": "module",
   "exports": {
@@ -11,7 +12,7 @@
     }
   },
   "dependencies": {
-    "@intx/inference-discovery": "0.2.2",
+    "@intx/inference-discovery": "0.3.0",
     "arktype": "^2.1.29"
   },
   "files": [