@intx/inference-discovery-openai 0.1.2 → 0.3.0

package/dist/protocol/body.js

@@ -0,0 +1,256 @@
+import { readFileSync } from "node:fs";
+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";
+    if (ref.kind === "audio")
+        return "audio/wav";
+    if (ref.kind === "video")
+        return "video/mp4";
+    if (ref.kind === "document")
+        return "application/pdf";
+    throw new Error(`unsupported media kind: ${String(ref.kind)}`);
+}
+function readMediaDataUri(ref) {
+    const abs = resolveMediaPath(ref);
+    const bytes = readFileSync(abs);
+    const mime = mimeTypeFor(ref);
+    return `data:${mime};base64,${bytes.toString("base64")}`;
+}
+function buildToolDecl(intent) {
+    if (!intent.tools || intent.tools.length === 0) {
+        throw new Error("intent has no tools but capability requires them");
+    }
+    return intent.tools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        },
+    }));
+}
+function buildPlainTextBody(model, intent, stream) {
+    const body = {
+        model,
+        messages: [{ role: "user", content: intent.prompt }],
+    };
+    if (stream)
+        body.stream = true;
+    return body;
+}
+function buildFunctionCallingBody(model, intent) {
+    const body = {
+        model,
+        messages: [{ role: "user", content: intent.prompt }],
+        tools: buildToolDecl(intent),
+    };
+    applyToolCallingEffort(body, model);
+    return body;
+}
+export function buildMultiTurnTurn1Body(opts) {
+    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);
+}
+function findToolFollowUp(intent) {
+    const followUp = intent.followUp;
+    if (followUp === undefined || followUp.length === 0) {
+        throw new Error("multi-turn: intent has no followUp entries");
+    }
+    for (const step of followUp) {
+        if (step.role === "tool") {
+            return { toolName: step.toolName, content: step.content };
+        }
+    }
+    throw new Error("multi-turn: intent.followUp has no role:'tool' entry");
+}
+function extractAssistantMessage(parsed) {
+    if (!isRecord(parsed)) {
+        throw new Error("multi-turn: turn-1 response is not a JSON object");
+    }
+    const choices = parsed.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        throw new Error("multi-turn: turn-1 response has no choices array");
+    }
+    const first = choices[0];
+    if (!isRecord(first)) {
+        throw new Error("multi-turn: turn-1 response choices[0] is not an object");
+    }
+    const message = first.message;
+    if (!isRecord(message)) {
+        throw new Error("multi-turn: turn-1 response choices[0].message is not an object");
+    }
+    return message;
+}
+function extractFirstToolCallId(message) {
+    const toolCalls = message.tool_calls;
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+        throw new Error("multi-turn: turn-1 assistant message has no tool_calls");
+    }
+    const first = toolCalls[0];
+    if (!isRecord(first)) {
+        throw new Error("multi-turn: turn-1 tool_calls[0] is not an object");
+    }
+    const id = first.id;
+    if (typeof id !== "string" || id.length === 0) {
+        throw new Error("multi-turn: turn-1 tool_calls[0].id is not a string");
+    }
+    return id;
+}
+export function buildMultiTurnTurn2Body(opts) {
+    const assistantMessage = extractAssistantMessage(opts.turn1Response);
+    const toolCallId = extractFirstToolCallId(assistantMessage);
+    const tool = findToolFollowUp(opts.intent);
+    const messages = [
+        ...opts.turn1Body.messages,
+        assistantMessage,
+        {
+            role: "tool",
+            tool_call_id: toolCallId,
+            content: tool.content,
+        },
+    ];
+    const tools = opts.turn1Body.tools;
+    const body = {
+        model: opts.model,
+        messages,
+    };
+    if (tools !== undefined) {
+        body.tools = tools;
+    }
+    applyToolCallingEffort(body, opts.model);
+    return body;
+}
+function buildReasoningBody(model, intent, stream) {
+    const body = {
+        model,
+        messages: [{ role: "user", content: intent.prompt }],
+    };
+    if (stream)
+        body.stream = true;
+    return body;
+}
+// Translate the intent's responseFormat to OpenAI's response_format
+// wire field. Mirrors toOpenAIResponseFormat in the inference adapter
+// (packages/inference/src/providers/openai.ts); duplicated here
+// because the discovery plug-in builds wire requests directly without
+// running through the adapter. Kept in sync by the shared
+// CapabilityIntent shape.
+function toOpenAIResponseFormat(format) {
+    switch (format.kind) {
+        case "text":
+            return { type: "text" };
+        case "json":
+            return { type: "json_object" };
+        case "json-schema": {
+            const jsonSchema = {
+                name: format.name,
+                schema: format.schema,
+            };
+            if (format.strict !== undefined)
+                jsonSchema["strict"] = format.strict;
+            return { type: "json_schema", json_schema: jsonSchema };
+        }
+    }
+}
+function buildStructuredOutputBody(model, intent, stream) {
+    if (intent.responseFormat === undefined) {
+        throw new Error("OpenAI protocol: structured-output intent has no responseFormat");
+    }
+    const body = {
+        model,
+        messages: [{ role: "user", content: intent.prompt }],
+        response_format: toOpenAIResponseFormat(intent.responseFormat),
+    };
+    if (stream)
+        body.stream = true;
+    return body;
+}
+// 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 ${capability} requires it`);
+    }
+    const parts = [{ type: "text", text: intent.prompt }];
+    for (const ref of intent.media) {
+        if (ref.kind !== expectedKind) {
+            throw new Error(`${capability} only accepts ${expectedKind} media, got: ${ref.kind}`);
+        }
+        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) {
+        case "plain-text":
+            return buildPlainTextBody(model, intent, false);
+        case "plain-text-streaming":
+            return buildPlainTextBody(model, intent, true);
+        case "function-calling":
+            return buildFunctionCallingBody(model, intent);
+        case "function-calling-multi-turn":
+            throw new Error("function-calling-multi-turn is a multi-step capability; use buildMultiTurnTurn1Body / buildMultiTurnTurn2Body via iterateCaptureSteps");
+        case "reasoning-content":
+            return buildReasoningBody(model, intent, false);
+        case "reasoning-content-streaming":
+            return buildReasoningBody(model, intent, true);
+        case "vision-input":
+            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 CapabilityNotBuildableError(capability, `OpenAI protocol: capability "${capability}" not implemented`);
+    }
+}

package/dist/protocol/endpoint.d.ts

@@ -0,0 +1 @@
+export declare function buildEndpointURL(baseUrl: string): string;

package/dist/protocol/endpoint.js

@@ -0,0 +1,3 @@
+export function buildEndpointURL(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+}

package/dist/protocol/iterator.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureStep, CapturedResponse, IterateCaptureStepsOpts } from "@intx/inference-discovery";
+export declare function createOpenaiIterator(baseUrl: string): (opts: IterateCaptureStepsOpts) => Generator<CaptureStep, void, CapturedResponse>;

package/dist/protocol/iterator.js

@@ -0,0 +1,37 @@
+import {} from "@intx/inference-discovery/catalog";
+import { buildEndpointURL } from "./endpoint.js";
+import { buildMultiTurnTurn1Body, buildMultiTurnTurn2Body, buildRequestBody, } from "./body.js";
+const MULTI_TURN_CAPABILITIES = new Set([
+    "function-calling-multi-turn",
+]);
+export function createOpenaiIterator(baseUrl) {
+    return function* iterateCaptureSteps(opts) {
+        const { model, capability, intent } = opts;
+        const url = buildEndpointURL(baseUrl);
+        if (MULTI_TURN_CAPABILITIES.has(capability)) {
+            const turn1 = buildMultiTurnTurn1Body({ model, intent });
+            const turn1Response = yield {
+                kind: "json",
+                url,
+                body: turn1,
+            };
+            const turn2 = buildMultiTurnTurn2Body({
+                model,
+                intent,
+                turn1Body: turn1,
+                turn1Response: turn1Response.parsed,
+            });
+            yield {
+                kind: "json",
+                url,
+                body: turn2,
+            };
+            return;
+        }
+        yield {
+            kind: "json",
+            url,
+            body: buildRequestBody({ model, capability, intent }),
+        };
+    };
+}

package/package.json

@@ -1,16 +1,27 @@
 {
   "name": "@intx/inference-discovery-openai",
-  "version": "0.1.2",
+  "description": "OpenAI-protocol provider plug-in for the inference discovery rig",
+  "version": "0.3.0",
   "license": "LGPL-2.1-only",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "intx-src": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@intx/inference-discovery": "0.0.0",
+    "@intx/inference-discovery": "0.3.0",
     "arktype": "^2.1.29"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/deployments/opencode-zen.ts

@@ -1,93 +0,0 @@
-import type { ProviderPlugin } from "@intx/inference-discovery";
-import { buildAuthHeaders } from "../protocol/auth";
-import { createOpenaiIterator } from "../protocol/iterator";
-
-const PROVIDER_NAME = "opencode-zen";
-
-const OPENCODE_ZEN_MODELS: readonly string[] = [
-  "kimi-k2.6",
-  "glm-5.1",
-  "deepseek-v4-pro",
-  "qwen3.6-plus",
-  "mimo-v2-omni",
-];
-
-const REDACT_REQUEST_HEADERS: readonly string[] = ["authorization"];
-const REDACT_RESPONSE_HEADERS: readonly string[] = [
-  "set-cookie",
-  "x-request-id",
-];
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function lookupPath(
-  value: unknown,
-  path: readonly (string | number)[],
-): unknown {
-  let cursor: unknown = 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: unknown): boolean {
-  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;
-}
-
-export interface ReasoningTrace {
-  fieldPath: string;
-  sample: unknown;
-}
-
-// 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: readonly (readonly (string | number)[])[] = [
-  ["choices", 0, "message", "reasoning_content"],
-  ["choices", 0, "message", "reasoning"],
-  ["choices", 0, "message", "reasoning_details"],
-];
-
-export function extractReasoningTrace(parsed: unknown): ReasoningTrace | null {
-  for (const path of REASONING_FIELD_PATHS) {
-    const value = lookupPath(parsed, path);
-    if (isNonEmpty(value)) {
-      return { fieldPath: path.join("."), sample: value };
-    }
-  }
-  return null;
-}
-
-export interface CreateOpencodeZenPluginOpts {
-  apiKey: string;
-  baseUrl: string;
-}
-
-export function createOpencodeZenPlugin(
-  opts: CreateOpencodeZenPluginOpts,
-): ProviderPlugin {
-  const { apiKey, baseUrl } = opts;
-  return {
-    name: PROVIDER_NAME,
-    models: OPENCODE_ZEN_MODELS,
-    redactRequestHeaders: REDACT_REQUEST_HEADERS,
-    redactResponseHeaders: REDACT_RESPONSE_HEADERS,
-    buildAuthHeaders: () => buildAuthHeaders(apiKey),
-    extractReasoningTrace,
-    iterateCaptureSteps: createOpenaiIterator(baseUrl),
-  };
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export {
-  createOpencodeZenPlugin,
-  extractReasoningTrace,
-  type CreateOpencodeZenPluginOpts,
-  type ReasoningTrace,
-} from "./deployments/opencode-zen";