@inflexa-ai/harness 0.30.1 → 0.30.2

package/dist/providers/ai-sdk.js

@@ -1,4 +1,4 @@
-import { generateText, streamText, wrapLanguageModel, } from "ai";
+import { streamText, wrapLanguageModel, } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
@@ -255,10 +255,10 @@ function requestedModelIdOf(model) {
 }
 /**
  * Capture the served model id at the raw model boundary, because that is the
- * only place it is still distinguishable from the requested one: `generateText`
- * and `streamText` both coalesce an unreported response model id to the bound
- * model's own id, so reading `result.response.modelId` would silently republish
- * the requested id as an endpoint's claim. A middleware sees the provider's
+ * only place it is still distinguishable from the requested one: `streamText`
+ * coalesces an unreported response model id to the bound model's own id, so
+ * reading `result.response.modelId` would silently republish the requested id
+ * as an endpoint's claim. A middleware sees the provider's
  * result before that fallback applies, so "reported nothing" stays absent.
  *
  * Built per call, never per provider: one provider instance serves concurrent
@@ -303,16 +303,6 @@ function responseFromMessages(input) {
     }
     return { message, finishReason, rawFinishReason, usage, requestedModelId, servedModelId };
 }
-function responseFromGenerate(result, identity) {
-    return responseFromMessages({
-        messages: result.responseMessages,
-        fallbackText: result.text,
-        finishReason: result.finishReason,
-        rawFinishReason: result.rawFinishReason,
-        usage: result.usage,
-        ...identity,
-    });
-}
 /**
  * Drop empty text parts — and messages left with no content at all — before
  * the wire call. The Anthropic Messages API rejects any request containing an
@@ -356,9 +346,57 @@ async function pullNextDelta(iterator) {
             return { kind: "delta", text: part.text };
         if (part.type === "abort")
             return { kind: "aborted", reason: part.reason };
+        // The SDK reports a wire failure as a part, not as a rejection, and it
+        // then closes the stream. Skipping it would turn a failed call into an
+        // empty assistant turn that the loop reads as a real answer.
+        if (part.type === "error")
+            return { kind: "failed", error: part.error };
     }
     return { kind: "end" };
 }
+/**
+ * The HTTP status that each Anthropic stream error type stands for.
+ *
+ * A provider names a mid-stream failure in the payload, not in the status line:
+ * a stream that carries `overloaded_error` reports the condition that a 529
+ * names on the non-streaming wire. The classifier reads the status alone, thus
+ * the part has to reach it as an error that names one, or the same condition
+ * would classify one way on `chat` and another way on `chatStream`.
+ */
+const STREAM_ERROR_STATUS = {
+    invalid_request_error: 400,
+    authentication_error: 401,
+    permission_error: 403,
+    not_found_error: 404,
+    request_too_large: 413,
+    rate_limit_error: 429,
+    timeout_error: 408,
+    api_error: 500,
+    overloaded_error: 529,
+};
+/**
+ * The failure that an `error` part of the SDK stream stands for.
+ *
+ * The part carries whatever the provider put on the wire, and that is often a
+ * bare object rather than an `Error`. Left as it is, it reaches the message as
+ * `[object Object]` and reaches the classifier with no status at all.
+ */
+function streamPartFailure(error) {
+    if (error instanceof Error)
+        return error;
+    if (typeof error !== "object" || error === null)
+        return new Error(String(error));
+    const reported = error;
+    const type = typeof reported.type === "string" ? reported.type : undefined;
+    const message = typeof reported.message === "string" ? reported.message : undefined;
+    const failure = new Error(message ?? type ?? "The provider reported a stream error.", { cause: error });
+    const status = type === undefined ? undefined : STREAM_ERROR_STATUS[type];
+    // `extractStatus` walks the chain for this field, thus the named condition
+    // classifies the same way it would from a status line.
+    if (status !== undefined)
+        Object.assign(failure, { status });
+    return failure;
+}
 /**
  * The failure that an `abort` part of the SDK stream stands for.
  *
@@ -394,16 +432,46 @@ export function createAiSdkProvider(deps) {
     const requestTimeoutMs = deps.requestTimeoutMs;
     const requestedModelId = requestedModelIdOf(deps.model);
     routeSdkWarningsTo(logger);
+    /**
+     * Record a call that the envelope gave up on.
+     *
+     * The envelope reports one attempt at `debug`, thus a deployment that runs
+     * at `info` keeps no trace of a call that exhausted its retries: the reply
+     * carries the failure to the user and the operator sees nothing. This is the
+     * one record that names the outcome.
+     */
+    function logFailure(session, failure, thrown) {
+        logger.error("provider call failed", {
+            workload: workloadOf(session),
+            kind: failure.type,
+            retryable: failure.retryable,
+            ...logger.errorFields(thrown),
+        });
+    }
     function chat(req, session, signal) {
         const run = async () => {
             const retry = createRetry(signal, logger, maxRetries);
             const capture = captureServedModelId(deps.model);
             try {
-                const result = await retry(async () => {
+                const collected = await retry(async () => {
                     // Attribution headers are time-limited; resolving them inside the
                     // retried closure keeps them fresh across a multi-minute window.
                     const headers = await resolveBillingHeaders(deps.resolveBilling, session);
-                    return generateText({
+                    // The call streams on the wire and collapses below.
+                    //
+                    // A non-streaming turn sends no header until the model completes,
+                    // thus the `headersTimeout` of the host HTTP client bounds the whole
+                    // generation. No option of the SDK lifts that bound, because it sits
+                    // under the fetch. Node defaults the field to 300s, and a turn near
+                    // 18k output tokens reaches it, while `DEFAULT_MAX_OUTPUT_TOKENS`
+                    // asks for up to 64k. A cut turn then costs twice: the envelope
+                    // starts the same generation again from zero.
+                    //
+                    // Anthropic states the rule for its own SDKs: a large `max_tokens`
+                    // makes streaming necessary, to prevent an HTTP timeout. Thus a
+                    // ceiling this size streams whether or not a consumer wants the
+                    // deltas, and `chatStream` stays the seam that forwards them.
+                    const result = streamText({
                         model: capture.model,
                         system: req.system,
                         messages: sanitizeMessages(req.messages),
@@ -416,20 +484,53 @@ export function createAiSdkProvider(deps) {
                         maxRetries: 0,
                         headers,
                         abortSignal: signal,
-                        // No SDK timeout rides here. `chunkMs` bounds a stream only,
-                        // thus it is inert on this call. The fetch guard is the full
-                        // bound, because the headers of a non-streaming response arrive
-                        // when the model completes.
+                        // `firstChunkMs` bounds the wait for the first content chunk,
+                        // and `chunkMs` bounds each later gap. Thus each silent interval
+                        // carries the one configured bound, and a turn that writes
+                        // steadily runs as long as it needs.
+                        ...(requestTimeoutMs !== undefined ? { timeout: { firstChunkMs: requestTimeoutMs, chunkMs: requestTimeoutMs } } : {}),
                         providerOptions: req.providerOptions,
                         reasoning: req.reasoning,
                     });
+                    // The drain sits inside the retried closure, thus a failure at any
+                    // point of the stream re-runs the whole attempt and the envelope
+                    // keeps its whole-call scope. No delta reaches a consumer here —
+                    // `chatStream` is the seam that forwards them.
+                    const iterator = result.fullStream[Symbol.asyncIterator]();
+                    let text = "";
+                    for (let pull = await pullNextDelta(iterator); pull.kind !== "end"; pull = await pullNextDelta(iterator)) {
+                        // A caller abort rides out as the reason of its own signal, thus
+                        // it stays a cancellation and reaches the caller as a throw.
+                        if (pull.kind === "aborted")
+                            throw abortedStreamFailure(signal, pull.reason, requestTimeoutMs);
+                        if (pull.kind === "failed")
+                            throw streamPartFailure(pull.error);
+                        text += pull.text;
+                    }
+                    // These promises settle only once the stream is fully drained, thus
+                    // the loop above must reach its end before this point.
+                    return {
+                        messages: await result.responseMessages,
+                        fallbackText: text,
+                        finishReason: await result.finishReason,
+                        rawFinishReason: await result.rawFinishReason,
+                        usage: await result.usage,
+                    };
                 });
-                return ok(responseFromGenerate(result, { requestedModelId, servedModelId: capture.servedModelId() }));
+                return ok(responseFromMessages({
+                    ...collected,
+                    requestedModelId,
+                    // Read after the drain: the metadata chunk that carries the
+                    // served id reaches the capture only as the stream is consumed.
+                    servedModelId: capture.servedModelId(),
+                }));
             }
             catch (e) {
                 if (isAbortError(e) || signal?.aborted)
                     throw e;
-                return err(toProviderError(unwrapForClassification(e), workloadOf(session)));
+                const failure = toProviderError(unwrapForClassification(e), workloadOf(session));
+                logFailure(session, failure, e);
+                return err(failure);
             }
         };
         return new ResultAsync(run());
@@ -477,6 +578,8 @@ export function createAiSdkProvider(deps) {
                 // fresh window under the retry policy of a connection error.
                 if (first.kind === "aborted")
                     throw abortedStreamFailure(signal, first.reason, requestTimeoutMs);
+                if (first.kind === "failed")
+                    throw streamPartFailure(first.error);
                 if (first.kind === "end") {
                     // A doStream promise rejection — the shape a real connection
                     // failure takes — does NOT surface at this first pull: streamText
@@ -522,6 +625,8 @@ export function createAiSdkProvider(deps) {
                 // terminal `ProviderError` from the throwable.
                 if (pull.kind === "aborted")
                     throw abortedStreamFailure(signal, pull.reason, requestTimeoutMs);
+                if (pull.kind === "failed")
+                    throw streamPartFailure(pull.error);
                 text += pull.text;
                 yield { type: "text-delta", text: pull.text };
             }
@@ -541,7 +646,9 @@ export function createAiSdkProvider(deps) {
         catch (e) {
             if (isAbortError(e) || signal?.aborted)
                 throw e;
-            throw toProviderError(unwrapForClassification(e), workloadOf(session));
+            const failure = toProviderError(unwrapForClassification(e), workloadOf(session));
+            logFailure(session, failure, e);
+            throw failure;
         }
     }
     // The provider advertises the guard limit on its own instance, thus a

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.30.1",
+    "version": "0.30.2",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",