@intx/inference 0.2.2 → 0.4.0

package/dist/harness.js

@@ -14,9 +14,10 @@
 // handling, or event emission. They translate request/response shapes.
 import { type } from "arktype";
 import { getLogger } from "@intx/log";
+import { detectResponseKind, } from "@intx/types/content-type";
 import { parseSSE } from "./sse.js";
 import { injectCredentials } from "./auth.js";
-import { classifyHTTPError, classifyNetworkError, classifyAbortError, classifyStreamError, classifyTimeoutError, ProtocolMismatchError, } from "./errors.js";
+import { classifyHTTPError, classifyNetworkError, classifyAbortError, classifyStreamError, classifyTimeoutError, classifyProtocolMismatch, ProtocolMismatchError, } from "./errors.js";
 import { createDefaultRetryPolicy } from "./retry-policy.js";
 const logger = getLogger(["interchange", "inference", "harness"]);
 /**
@@ -70,6 +71,13 @@ export function createDependencies(adapters) {
         adapters,
     };
 }
+// Fail-closed default resolver, installed when a caller supplies no
+// `readMaterial`. It throws only if a request actually reaches a credential
+// sentinel, so a sentinel-free mock harness runs without a resolver while a
+// real credentialed request surfaces the missing wiring loudly.
+const unconfiguredCredentialResolver = (credentialId) => {
+    throw new Error(`no credential resolver supplied to the inference harness, but a request needs the secret for credential ${credentialId}`);
+};
 /**
  * Run one fetch lifecycle and yield its events. Ends on the first
  * `inference.error` or `inference.done`. The outer `runInference`
@@ -81,7 +89,7 @@ export function createDependencies(adapters) {
  * directly would bypass retry handling.
  */
 async function* runSingleAttempt(opts) {
-    const { turns, source, inferenceOptions, signal, nextSeq, deps } = opts;
+    const { turns, source, inferenceOptions, signal, nextSeq, readMaterial, deps, } = opts;
     // Per-call options override source-bound defaults. The merge happens
     // here, once, so the adapter and timeout-resolution paths below all
     // see the effective option set without having to remember the
@@ -128,6 +136,9 @@ async function* runSingleAttempt(opts) {
     // different keys.
     const citationsByIndex = new Map();
     const unindexedCitations = [];
+    // Prompt-level safety signals (no candidate index on the first
+    // capture). Appended to the finalized turn after indexed blocks.
+    const unindexedSafetyRatings = [];
     let usageSeen = null;
     const openToolCalls = new Map();
     // OpenAI uses index-based tracking before we have a real callId.
@@ -142,7 +153,7 @@ async function* runSingleAttempt(opts) {
     }
     let adapter;
     try {
-        adapter = deps.adapters.resolve(lastCycleSource);
+        adapter = deps.adapters.resolve(lastCycleSource, source.quirks);
     }
     catch (cause) {
         yield {
@@ -177,7 +188,7 @@ async function* runSingleAttempt(opts) {
     }
     // Resolve the full URL and inject credentials.
     const url = resolveURL(builtRequest.url, source.baseURL);
-    const headers = injectCredentials(builtRequest.headers, source);
+    const headers = injectCredentials(builtRequest.headers, source, readMaterial ?? unconfiguredCredentialResolver);
     // Per-call timeouts. The inactivity timer fires when the harness
     // hasn't yielded an event for `inactivityTimeoutMs`; the total timer
     // is a wall-clock cap from fetch onwards. We own one AbortController,
@@ -309,13 +320,55 @@ async function* runSingleAttempt(opts) {
             };
             return;
         }
+        // Captured as a const so the non-null narrowing from the guard above
+        // carries into the SSE branch of the event-source generator below (a
+        // bare `response.body` re-widens to nullable across the closure).
+        const responseBody = response.body;
+        let responseKind;
+        try {
+            responseKind = detectResponseKind(response.headers);
+        }
+        catch (cause) {
+            // A 2xx whose Content-Type is neither SSE nor JSON is a protocol
+            // violation, not a transient failure — surface it loudly rather than
+            // pushing unknown bytes through the SSE parser to yield an empty turn.
+            yield {
+                type: "inference.error",
+                seq: nextSeq(),
+                data: {
+                    error: classifyProtocolMismatch(cause instanceof Error ? cause.message : String(cause)),
+                    partial: snapshotPartial(partial),
+                },
+            };
+            return;
+        }
         // Arm the inactivity timer now that the SSE stream is open. Every
         // event we yield below resets it; sustained silence past
         // `inactivityTimeoutMs` aborts the controller and the loop's catch
-        // surfaces the timeout error.
-        armInactivity();
+        // surfaces the timeout error. A non-streaming JSON body has no
+        // inter-event silence to detect, so the timer stays disarmed there and
+        // the total-timeout controller alone bounds the buffered read.
+        if (responseKind === "sse") {
+            armInactivity();
+        }
+        // The event source: one branch per response kind, both feeding batches
+        // of raw adapter events into the shared accumulator below. SSE yields
+        // one batch per wire chunk; JSON buffers the whole body and yields a
+        // single batch.
+        const rawEventBatches = async function* () {
+            if (responseKind === "json") {
+                const body = await awaitWithSignal(response.text(), fetchSignal);
+                yield adapter.parseJSONResponse(body);
+                return;
+            }
+            for await (const sseData of parseSSE(responseBody)) {
+                // Reset inactivity timer — we just got something from the wire.
+                armInactivity();
+                yield adapter.parseResponse(sseData);
+            }
+        };
         try {
-            for await (const sseData of parseSSE(response.body)) {
+            for await (const rawEvents of rawEventBatches()) {
                 if (timeoutReason !== null) {
                     // The timeout aborted the stream; bubble up the right error
                     // shape rather than letting the abort masquerade as a
@@ -344,9 +397,6 @@ async function* runSingleAttempt(opts) {
                     };
                     return;
                 }
-                // Reset inactivity timer — we just got something from the wire.
-                armInactivity();
-                const rawEvents = adapter.parseResponse(sseData);
                 for (const raw of rawEvents) {
                     switch (raw.type) {
                         case "inference.text.delta": {
@@ -372,6 +422,7 @@ async function* runSingleAttempt(opts) {
                                 data: {
                                     token: raw.data.token,
                                     partial: snapshotPartial(partial),
+                                    index: idx,
                                 },
                             };
                             break;
@@ -432,24 +483,33 @@ async function* runSingleAttempt(opts) {
                                 data: {
                                     token: raw.data.token,
                                     partial: snapshotPartial(partial),
+                                    index: idx,
                                 },
                             };
                             break;
                         }
-                        case "inference.thinking.signature": {
-                            const idx = requireIndex(raw, "thinking.signature");
+                        case "inference.block.signature": {
+                            const idx = requireIndex(raw, "block.signature");
                             const existing = blockMap.get(idx);
                             if (existing === undefined) {
-                                throw new ProtocolMismatchError(`harness: thinking.signature at index ${String(idx)} has no preceding thinking block at that index`, raw);
+                                throw new ProtocolMismatchError(`harness: block.signature at index ${String(idx)} has no preceding block at that index`, raw);
                             }
-                            if (existing.kind !== "thinking") {
-                                throw new ProtocolMismatchError(`harness: thinking.signature at index ${String(idx)} targets an existing ${existing.kind} block, not a thinking block`, raw);
+                            // A signature authenticates the block whose part it rides on.
+                            // The signable kinds are the ones whose ContentBlock carries a
+                            // `signature` field; the others (redacted_thinking, refusal,
+                            // code_execution_result) have no place to hold one.
+                            if (existing.kind !== "thinking" &&
+                                existing.kind !== "text" &&
+                                existing.kind !== "tool_use" &&
+                                existing.kind !== "image" &&
+                                existing.kind !== "code_execution_request") {
+                                throw new ProtocolMismatchError(`harness: block.signature at index ${String(idx)} targets an existing ${existing.kind} block, which does not carry a signature`, raw);
                             }
                             existing.signature = raw.data.signature;
                             yield {
-                                type: "inference.thinking.signature",
+                                type: "inference.block.signature",
                                 seq: nextSeq(),
-                                data: { signature: raw.data.signature },
+                                data: { signature: raw.data.signature, index: idx },
                             };
                             break;
                         }
@@ -476,6 +536,16 @@ async function* runSingleAttempt(opts) {
                             };
                             break;
                         }
+                        case "inference.safety_rating": {
+                            const safetyRating = raw.data.safetyRating;
+                            unindexedSafetyRatings.push(safetyRating);
+                            yield {
+                                type: "inference.safety_rating",
+                                seq: nextSeq(),
+                                data: { safetyRating },
+                            };
+                            break;
+                        }
                         case "inference.thinking.redacted": {
                             const idx = requireIndex(raw, "thinking.redacted");
                             const existing = blockMap.get(idx);
@@ -536,7 +606,12 @@ async function* runSingleAttempt(opts) {
                             yield {
                                 type: "inference.tool_call.start",
                                 seq: nextSeq(),
-                                data: { callId, name, partial: snapshotPartial(partial) },
+                                data: {
+                                    callId,
+                                    name,
+                                    partial: snapshotPartial(partial),
+                                    index: toolIdx,
+                                },
                             };
                             break;
                         }
@@ -837,9 +912,19 @@ async function* runSingleAttempt(opts) {
         };
         for (const [idx, entry] of blockMap.entries()) {
             if (entry.kind === "text") {
-                if (entry.text.length > 0) {
-                    emit({ type: "text", text: entry.text }, idx);
+                // Emit even with empty text if a signature was captured, so a
+                // signature riding on an otherwise-empty text carrier still
+                // round-trips (mirrors the thinking-block rule below).
+                if (entry.text.length === 0 && entry.signature === undefined) {
+                    continue;
                 }
+                emit({
+                    type: "text",
+                    text: entry.text,
+                    ...(entry.signature !== undefined
+                        ? { signature: entry.signature }
+                        : {}),
+                }, idx);
                 continue;
             }
             if (entry.kind === "thinking") {
@@ -890,7 +975,12 @@ async function* runSingleAttempt(opts) {
                     // the tool call from the final turn.
                     throw new ProtocolMismatchError(`harness: tool_use marker at callId ${entry.callId} has no matching completed tool call`, entry);
                 }
-                emit(finalized, idx);
+                if (finalized.type !== "tool_call") {
+                    throw new ProtocolMismatchError(`harness: tool_use marker at callId ${entry.callId} resolved to a ${finalized.type} block, not a tool_call`, entry);
+                }
+                emit(entry.signature !== undefined
+                    ? { ...finalized, signature: entry.signature }
+                    : finalized, idx);
                 continue;
             }
             if (entry.kind === "image") {
@@ -900,7 +990,9 @@ async function* runSingleAttempt(opts) {
                 // atomic, not streamed), so the final-walk emits it
                 // verbatim. Citation interleave applies the same way as
                 // any other block kind.
-                emit(entry.image, idx);
+                emit(entry.signature !== undefined
+                    ? { ...entry.image, signature: entry.signature }
+                    : entry.image, idx);
                 continue;
             }
             if (entry.kind === "code_execution_request") {
@@ -910,7 +1002,9 @@ async function* runSingleAttempt(opts) {
                 // current wire delivers all of it atomically on `start`;
                 // streaming providers would extend `request.code` via the
                 // delta handler before this walk runs.
-                emit(entry.request, idx);
+                emit(entry.signature !== undefined
+                    ? { ...entry.request, signature: entry.signature }
+                    : entry.request, idx);
                 continue;
             }
             if (entry.kind === "code_execution_result") {
@@ -931,6 +1025,7 @@ async function* runSingleAttempt(opts) {
             throw new ProtocolMismatchError(`harness: ${String(citationsByIndex.size)} citation index/indices have no matching emitted block in the final turn: ${orphanIndices.join(", ")}`, { orphanIndices });
         }
         contentBlocks.push(...unindexedCitations);
+        contentBlocks.push(...unindexedSafetyRatings);
         const finalTurn = {
             role: "assistant",
             content: contentBlocks,

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { createDefaultRetryPolicy } from "./retry-policy.js";
 export type { RetryPolicy, RetrySituation, RetryDecision, } from "@intx/types/runtime";
 export { uploadGoogleGenAIFile } from "./providers/google-genai-files.js";
 export type { UploadGoogleGenAIFileOpts, UploadGoogleGenAIFileFetch, UploadedGoogleGenAIFile, } from "./providers/google-genai-files.js";
-export { createInboundTurn } from "./turns.js";
+export { createInboundTurn, assertWellFormedToolSequence } from "./turns.js";
 export { createReactor } from "./reactor.js";
 export type { Reactor, ReactorConfig, ReactorEmittedEvent } from "./reactor.js";
 export { validateActions } from "./actions.js";

package/dist/index.js

@@ -7,7 +7,7 @@ export { classifyHTTPError, classifyNetworkError, classifyAbortError, classifySt
 export { transformMessages, createIDNormalizer } from "./transform.js";
 export { createDefaultRetryPolicy } from "./retry-policy.js";
 export { uploadGoogleGenAIFile } from "./providers/google-genai-files.js";
-export { createInboundTurn } from "./turns.js";
+export { createInboundTurn, assertWellFormedToolSequence } from "./turns.js";
 export { createReactor } from "./reactor.js";
 export { validateActions } from "./actions.js";
 export { createGateManager } from "./gates.js";

package/dist/providers/anthropic.d.ts

@@ -1,5 +1,7 @@
 import type { LastCycleSource } from "@intx/types/runtime";
 import type { ProviderAdapter } from "../adapter.js";
+export declare const ADAPTIVE_THINKING_MODELS: ReadonlySet<string>;
+export declare const ADAPTIVE_THINKING_EFFORT = "high";
 export type AnthropicRawEvent = {
     kind: "text_delta";
     token: string;
@@ -30,4 +32,6 @@ export type AnthropicRawEvent = {
 } | {
     kind: "skip";
 };
-export declare function createAnthropicAdapter(source: LastCycleSource): ProviderAdapter;
+export declare const AnthropicQuirks: import("arktype/internal/variants/object.ts").ObjectType<{}, {}>;
+export type AnthropicQuirks = typeof AnthropicQuirks.infer;
+export declare function createAnthropicAdapter(source: LastCycleSource, quirks?: unknown): ProviderAdapter;