@jaypie/llm 1.3.12 → 1.3.13

package/dist/cjs/operate/adapters/FireworksAdapter.d.ts

@@ -106,6 +106,7 @@ type FireworksContentPart = {
 export declare class FireworksAdapter extends BaseProviderAdapter {
     readonly name: "fireworks";
     readonly defaultModel: string;
+    readonly supportsStructuredOutputRetry = true;
     private runtimeNoStructuredOutputModels;
     rememberModelRejectsStructuredOutput(model: string): void;
     clearRuntimeNoStructuredOutputModels(): void;

package/dist/cjs/operate/adapters/ProviderAdapter.interface.d.ts

@@ -20,6 +20,12 @@ export interface ProviderAdapter {
      * Default model for this provider
      */
     readonly defaultModel: string;
+    /**
+     * Whether OperateLoop may take a corrective turn when a `format` request
+     * completes with prose instead of structured output (tool-emulation
+     * providers opt in).
+     */
+    readonly supportsStructuredOutputRetry?: boolean;
     /**
      * Build a provider-specific request from the standardized format
      *
@@ -169,6 +175,13 @@ export declare abstract class BaseProviderAdapter implements ProviderAdapter {
     abstract responseToHistoryItems(response: unknown): LlmHistory;
     abstract classifyError(error: unknown): ClassifiedError;
     abstract isComplete(response: unknown): boolean;
+    /**
+     * Whether OperateLoop may take a corrective turn when a `format` request
+     * completes with prose instead of structured output. Providers whose
+     * structured output rides a tool emulation (where compliance is a model
+     * decision) opt in; native grammar-constrained providers do not need it.
+     */
+    readonly supportsStructuredOutputRetry: boolean;
     /**
      * Default implementation checks if error is retryable via classifyError
      */

package/dist/cjs/operate/types.d.ts

@@ -77,6 +77,13 @@ export interface OperateRequest {
     stream?: boolean;
     /** Sampling temperature (0-2 for most providers) */
     temperature?: number;
+    /**
+     * Set by OperateLoop on a corrective turn after a format request came back
+     * as prose. Adapters that support the retry (see
+     * `ProviderAdapter.supportsStructuredOutputRetry`) should offer only the
+     * structured-output mechanism on this turn.
+     */
+    structuredOutputRetry?: boolean;
     /** User identifier for tracking */
     user?: string;
 }
@@ -135,6 +142,8 @@ import type { ResponseBuilder } from "./response/ResponseBuilder.js";
 export interface OperateLoopState {
     /** Count of consecutive tool errors (resets on success) */
     consecutiveToolErrors: number;
+    /** Set when the loop has taken a corrective structured-output turn */
+    structuredOutputRetry?: boolean;
     /** Current conversation input/messages */
     currentInput: LlmHistory;
     /** Current turn number (0-indexed, incremented at start of each turn) */

package/dist/esm/index.js

@@ -482,6 +482,15 @@ function resolveModelChain(model) {
  * Providers can extend this class to reduce boilerplate.
  */
 class BaseProviderAdapter {
+    constructor() {
+        /**
+         * Whether OperateLoop may take a corrective turn when a `format` request
+         * completes with prose instead of structured output. Providers whose
+         * structured output rides a tool emulation (where compliance is a model
+         * decision) opt in; native grammar-constrained providers do not need it.
+         */
+        this.supportsStructuredOutputRetry = false;
+    }
     /**
      * Default implementation checks if error is retryable via classifyError
      */
@@ -3409,6 +3418,10 @@ class FireworksAdapter extends BaseProviderAdapter {
         super(...arguments);
         this.name = PROVIDER.FIREWORKS.NAME;
         this.defaultModel = PROVIDER.FIREWORKS.DEFAULT;
+        // Structured output with tools rides the structured_output tool emulation
+        // (Fireworks rejects response_format + tools), and emulation compliance is
+        // a model decision — opt in to OperateLoop's corrective retry turn.
+        this.supportsStructuredOutputRetry = true;
         // Session-level cache of models observed to reject native
         // `response_format: json_schema`. When a model is in this set, buildRequest
         // engages the legacy fake-tool path instead of native structured output.
@@ -3463,9 +3476,10 @@ class FireworksAdapter extends BaseProviderAdapter {
         const useFallbackStructuredOutput = Boolean(request.format) &&
             (hasCallerTools ||
                 !this.supportsStructuredOutput(fireworksRequest.model));
-        const allTools = request.tools
-            ? [...request.tools]
-            : [];
+        // On a corrective retry turn (the model answered a format request with
+        // prose), offer only the structured_output tool so the demanded call is
+        // the sole option.
+        const allTools = request.tools && !request.structuredOutputRetry ? [...request.tools] : [];
         if (useFallbackStructuredOutput && request.format) {
             log$2.warn(hasCallerTools
                 ? `[FireworksAdapter] Fireworks does not support response_format combined with tools; using structured_output tool emulation for model ${fireworksRequest.model}.`
@@ -8006,6 +8020,31 @@ function createErrorClassifier(adapter) {
         },
     };
 }
+/**
+ * Attempt to read a prose response as the structured payload itself: parse the
+ * text (stripping a Markdown code fence if present) and return the object, or
+ * undefined when the text is not a JSON object.
+ */
+function tryParseJsonObject(text) {
+    let candidate = text.trim();
+    const fence = candidate.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/);
+    if (fence) {
+        candidate = fence[1].trim();
+    }
+    if (!candidate.startsWith("{")) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(candidate);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Not JSON; caller falls through to the corrective-turn path.
+    }
+    return undefined;
+}
 //
 //
 // Main
@@ -8074,6 +8113,7 @@ class OperateLoop {
                     messages: state.currentInput,
                     model: modelName,
                     providerOptions: options.providerOptions,
+                    structuredOutputRetry: state.structuredOutputRetry,
                     system: options.system,
                     temperature: options.temperature,
                     tools: state.formattedTools,
@@ -8477,6 +8517,42 @@ class OperateLoop {
                 return true; // Continue to next turn
             }
         }
+        // Format contract enforcement: the loop is about to complete but the
+        // model answered with prose instead of structured output.
+        if (state.formattedFormat && typeof parsed.content === "string") {
+            // First salvage attempt: the text may be the JSON itself (with or
+            // without a code fence).
+            const salvaged = tryParseJsonObject(parsed.content);
+            if (salvaged) {
+                state.responseBuilder.setContent(this.applyFormatArrayDefaults(salvaged, options));
+                state.responseBuilder.complete();
+                for (const item of this.adapter.responseToHistoryItems(parsed.raw)) {
+                    state.responseBuilder.appendToHistory(item);
+                }
+                return false; // Stop loop
+            }
+            // Corrective turn: for adapters whose structured output rides a tool
+            // emulation, take another turn offering only the structured_output tool
+            // and demand it be called. Bounded by maxTurns.
+            if (this.adapter.supportsStructuredOutputRetry &&
+                state.currentTurn < state.maxTurns) {
+                log.warn(`[operate] Model returned text despite format on turn ${state.currentTurn}; retrying with structured_output tool only`);
+                for (const item of this.adapter.responseToHistoryItems(parsed.raw)) {
+                    state.currentInput.push(item);
+                    state.responseBuilder.appendToHistory(item);
+                }
+                const corrective = {
+                    content: "You must provide your final answer by calling the structured_output tool " +
+                        "with arguments matching the required schema. Do not respond with text.",
+                    role: LlmMessageRole.User,
+                    type: LlmMessageType.Message,
+                };
+                state.currentInput.push(corrective);
+                state.responseBuilder.appendToHistory(corrective);
+                state.structuredOutputRetry = true;
+                return true; // Continue to corrective turn
+            }
+        }
         // No tool calls or no toolkit - we're done
         state.responseBuilder.setContent(this.applyFormatArrayDefaults(parsed.content, options));
         state.responseBuilder.complete();