@fabric-harness/sdk 1.13.0 → 2.0.0

package/dist/model.js

@@ -7,61 +7,78 @@ export function toolsToModelSchemas(tools) {
         ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
     }));
 }
+const MAX_TRANSIENT_MODEL_RETRIES = 3;
+const TRANSIENT_MODEL_RETRY_BASE_DELAY_MS = 2_000;
 export async function generateWithRuntime(provider, request, options = {}) {
-    const maxAttempts = (options.retries ?? 0) + 1;
+    const maxAttempts = (options.retries ?? MAX_TRANSIENT_MODEL_RETRIES) + 1;
+    const baseDelayMs = options.retryDelayMs ?? TRANSIENT_MODEL_RETRY_BASE_DELAY_MS;
     let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const startedAt = Date.now();
-        const controller = new AbortController();
-        const timeout = options.timeoutMs
-            ? setTimeout(() => controller.abort(new Error(`Model call timed out after ${options.timeoutMs}ms`)), options.timeoutMs)
-            : undefined;
-        const abortListener = () => controller.abort(options.signal?.reason);
-        options.signal?.addEventListener('abort', abortListener, { once: true });
-        await options.onAttempt?.({ provider: provider.name, attempt, maxAttempts, status: 'start', ...(request.model !== undefined ? { model: request.model } : {}) });
-        try {
-            const response = await provider.generate({ ...request, signal: controller.signal });
-            if (timeout)
-                clearTimeout(timeout);
-            options.signal?.removeEventListener('abort', abortListener);
-            await options.onAttempt?.({
-                provider: provider.name,
-                attempt,
-                maxAttempts,
-                status: 'success',
-                durationMs: Date.now() - startedAt,
-                ...(request.model !== undefined ? { model: request.model } : {}),
-                ...(response.usage !== undefined ? { usage: response.usage } : {}),
-            });
-            return response;
-        }
-        catch (error) {
-            if (timeout)
-                clearTimeout(timeout);
-            options.signal?.removeEventListener('abort', abortListener);
-            lastError = error;
-            const message = error instanceof Error ? error.message : String(error);
-            const canRetry = attempt < maxAttempts && !options.signal?.aborted && isRetryableModelError(error);
-            await options.onAttempt?.({
-                provider: provider.name,
-                attempt,
-                maxAttempts,
-                status: canRetry ? 'retry' : 'error',
-                durationMs: Date.now() - startedAt,
-                ...(request.model !== undefined ? { model: request.model } : {}),
-                error: message,
-            });
-            if (!canRetry)
-                break;
-            // Honor Retry-After when the provider supplied one — saves wasted
-            // retries during quota crunches. Falls back to exponential backoff.
-            const retryAfterMs = error instanceof ProviderHttpError ? error.retryAfterMs : undefined;
-            const waitMs = retryAfterMs && retryAfterMs > 0
-                ? Math.min(retryAfterMs, 60_000)
-                : retryDelay(options.retryDelayMs ?? 250, attempt);
-            await delay(waitMs);
+    // Dedicated abort controller for retry sleeps — separate from the
+    // per-attempt timeout controller so that session.abort() can cancel
+    // a pending backoff without tearing down an in-flight model call.
+    const retryAbortController = new AbortController();
+    const onCallerAbort = () => retryAbortController.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', onCallerAbort, { once: true });
+    try {
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            if (options.signal?.aborted) {
+                throw createAbortError(options.signal.reason);
+            }
+            const startedAt = Date.now();
+            const controller = new AbortController();
+            const timeout = options.timeoutMs
+                ? setTimeout(() => controller.abort(new Error(`Model call timed out after ${options.timeoutMs}ms`)), options.timeoutMs)
+                : undefined;
+            const abortListener = () => controller.abort(options.signal?.reason);
+            options.signal?.addEventListener('abort', abortListener, { once: true });
+            await options.onAttempt?.({ provider: provider.name, attempt, maxAttempts, status: 'start', ...(request.model !== undefined ? { model: request.model } : {}) });
+            try {
+                const response = await provider.generate({ ...request, signal: controller.signal });
+                if (timeout)
+                    clearTimeout(timeout);
+                options.signal?.removeEventListener('abort', abortListener);
+                await options.onAttempt?.({
+                    provider: provider.name,
+                    attempt,
+                    maxAttempts,
+                    status: 'success',
+                    durationMs: Date.now() - startedAt,
+                    ...(request.model !== undefined ? { model: request.model } : {}),
+                    ...(response.usage !== undefined ? { usage: response.usage } : {}),
+                });
+                return response;
+            }
+            catch (error) {
+                if (timeout)
+                    clearTimeout(timeout);
+                options.signal?.removeEventListener('abort', abortListener);
+                lastError = error;
+                const message = error instanceof Error ? error.message : String(error);
+                const canRetry = attempt < maxAttempts && !options.signal?.aborted && isRetryableModelError(error);
+                await options.onAttempt?.({
+                    provider: provider.name,
+                    attempt,
+                    maxAttempts,
+                    status: canRetry ? 'retry' : 'error',
+                    durationMs: Date.now() - startedAt,
+                    ...(request.model !== undefined ? { model: request.model } : {}),
+                    error: message,
+                });
+                if (!canRetry)
+                    break;
+                // Honor Retry-After when the provider supplied one — saves wasted
+                // retries during quota crunches. Falls back to exponential backoff.
+                const retryAfterMs = error instanceof ProviderHttpError ? error.retryAfterMs : undefined;
+                const waitMs = retryAfterMs && retryAfterMs > 0
+                    ? Math.min(retryAfterMs, 60_000)
+                    : calculateRetryDelay(baseDelayMs, attempt);
+                await sleepWithAbort(waitMs, retryAbortController.signal);
+            }
         }
     }
+    finally {
+        options.signal?.removeEventListener('abort', onCallerAbort);
+    }
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 export class MockModelProvider {
@@ -82,10 +99,78 @@ export class MockModelProvider {
         return { message: { role: 'assistant', content }, usage: estimateUsage([...request.messages, { role: 'assistant', content }]) };
     }
 }
+// ─── Reasoning effort ────────────────────────────────────────────────────────
+//
+// Conservative capability detection for the native HTTP providers (the default
+// pi-agent-core loop does its own per-model clamping). Reasoning is only ever
+// applied when a caller explicitly sets `thinkingLevel`; a false negative here
+// safely drops the level, while sending an unsupported control would 400. Keep
+// the patterns tight and matched to well-established reasoning model families.
+const REASONING_MODEL_PATTERNS = [
+    /^o\d/i, // OpenAI o-series: o1, o3, o4...
+    /^gpt-5/i, // OpenAI gpt-5 family
+    /gpt-oss/i, // OpenAI open-weights reasoning
+    /^claude-3-7/i, // Claude 3.7 extended thinking
+    /^claude-(opus|sonnet|haiku)-4/i, // Claude 4.x families
+    /^gemini-2\.5/i, // Gemini 2.5 thinking
+];
+/** Whether a model id (with or without provider prefix) is a known reasoning model. */
+export function modelSupportsReasoning(model) {
+    const id = model.includes('/') ? model.slice(model.lastIndexOf('/') + 1) : model;
+    return REASONING_MODEL_PATTERNS.some((re) => re.test(id));
+}
+/** True when a reasoning control should be applied for this model + requested level. */
+function shouldApplyReasoning(model, level) {
+    return level !== undefined && level !== 'off' && modelSupportsReasoning(model);
+}
+/** OpenAI / Workers-AI style `reasoning_effort` value. */
+function openAIReasoningEffort(level) {
+    switch (level) {
+        case 'minimal':
+        case 'low':
+            return 'low';
+        case 'medium':
+            return 'medium';
+        case 'high':
+        case 'xhigh':
+            return 'high';
+    }
+}
+/** Anthropic extended-thinking token budget (>= 1024; `max_tokens` must exceed it). */
+function anthropicThinkingBudget(level) {
+    switch (level) {
+        case 'minimal':
+            return 1024;
+        case 'low':
+            return 2048;
+        case 'medium':
+            return 4096;
+        case 'high':
+            return 8192;
+        case 'xhigh':
+            return 16384;
+    }
+}
+/** Gemini `thinkingConfig.thinkingBudget` token count. */
+function geminiThinkingBudget(level) {
+    switch (level) {
+        case 'minimal':
+            return 512;
+        case 'low':
+            return 1024;
+        case 'medium':
+            return 4096;
+        case 'high':
+            return 12288;
+        case 'xhigh':
+            return 24576;
+    }
+}
 export class OpenAICompatibleModelProvider {
     name;
     baseUrl;
     apiKey;
+    tokenProvider;
     defaultModel;
     headers;
     rateLimiter;
@@ -94,30 +179,37 @@ export class OpenAICompatibleModelProvider {
         this.name = options.name ?? 'openai-compatible';
         this.baseUrl = options.baseUrl.replace(/\/$/, '');
         this.apiKey = options.apiKey;
+        this.tokenProvider = options.tokenProvider;
         if (options.defaultModel !== undefined)
             this.defaultModel = options.defaultModel;
         this.headers = options.headers ?? {};
         this.rateLimiter = options.rateLimiter;
         this.rateLimitKey = `${this.name}:${rateLimitKeyForApiKey(this.apiKey)}`;
     }
+    /** Resolves the bearer token for a request: the rotating `tokenProvider` if set, else `apiKey`. */
+    async authToken() {
+        return this.tokenProvider ? await this.tokenProvider() : this.apiKey;
+    }
     async generate(request) {
         const model = request.model ?? this.defaultModel;
         if (!model)
             throw new Error(`${this.name}: model is required.`);
         if (this.rateLimiter)
             await this.rateLimiter.acquire(this.rateLimitKey, request.signal ? { signal: request.signal } : undefined);
+        const token = await this.authToken();
         const init = {
             method: 'POST',
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
             headers: {
                 'content-type': 'application/json',
-                authorization: `Bearer ${this.apiKey}`,
+                authorization: `Bearer ${token}`,
                 ...this.headers,
             },
             body: JSON.stringify({
                 model,
                 messages: request.messages.map(toOpenAIMessage),
                 ...(request.tools !== undefined ? { tools: request.tools.map(toOpenAITool) } : {}),
+                ...(shouldApplyReasoning(model, request.thinkingLevel) ? { reasoning_effort: openAIReasoningEffort(request.thinkingLevel) } : {}),
             }),
         };
         const response = await fetch(`${this.baseUrl}/chat/completions`, init);
@@ -143,12 +235,13 @@ export class OpenAICompatibleModelProvider {
             throw new Error(`${this.name}: model is required.`);
         if (this.rateLimiter)
             await this.rateLimiter.acquire(this.rateLimitKey, request.signal ? { signal: request.signal } : undefined);
+        const token = await this.authToken();
         const init = {
             method: 'POST',
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
             headers: {
                 'content-type': 'application/json',
-                authorization: `Bearer ${this.apiKey}`,
+                authorization: `Bearer ${token}`,
                 accept: 'text/event-stream',
                 ...this.headers,
             },
@@ -158,6 +251,7 @@ export class OpenAICompatibleModelProvider {
                 stream_options: { include_usage: true },
                 messages: request.messages.map(toOpenAIMessage),
                 ...(request.tools !== undefined ? { tools: request.tools.map(toOpenAITool) } : {}),
+                ...(shouldApplyReasoning(model, request.thinkingLevel) ? { reasoning_effort: openAIReasoningEffort(request.thinkingLevel) } : {}),
             }),
         };
         const response = await fetch(`${this.baseUrl}/chat/completions`, init);
@@ -283,7 +377,7 @@ export class GeminiModelProvider {
             method: 'POST',
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
             headers: { 'content-type': 'application/json', ...this.headers },
-            body: JSON.stringify(toGeminiRequest(request)),
+            body: JSON.stringify(toGeminiRequest(request, model)),
         });
         if (!response.ok)
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text(), response.headers);
@@ -317,7 +411,7 @@ export class VertexAIModelProvider {
             method: 'POST',
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
             headers: { 'content-type': 'application/json', authorization: `Bearer ${this.accessToken}`, ...this.headers },
-            body: JSON.stringify(toGeminiRequest(request)),
+            body: JSON.stringify(toGeminiRequest(request, model)),
         });
         if (!response.ok)
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text(), response.headers);
@@ -452,11 +546,13 @@ export class AnthropicModelProvider {
         if (this.rateLimiter)
             await this.rateLimiter.acquire(this.rateLimitKey, request.signal ? { signal: request.signal } : undefined);
         const { system, messages } = toAnthropicMessages(request.messages);
+        const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel) ? anthropicThinkingBudget(request.thinkingLevel) : undefined;
+        const maxTokens = thinkingBudget !== undefined ? Math.max(this.maxTokens, thinkingBudget + 1024) : this.maxTokens;
         const response = await fetch(`${this.baseUrl}/messages`, {
             method: 'POST',
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
             headers: { 'content-type': 'application/json', 'x-api-key': this.apiKey, 'anthropic-version': '2023-06-01', ...this.headers },
-            body: JSON.stringify({ model, max_tokens: this.maxTokens, ...(system ? { system } : {}), messages, ...(request.tools !== undefined ? { tools: request.tools.map(toAnthropicTool) } : {}) }),
+            body: JSON.stringify({ model, max_tokens: maxTokens, ...(thinkingBudget !== undefined ? { thinking: { type: 'enabled', budget_tokens: thinkingBudget } } : {}), ...(system ? { system } : {}), messages, ...(request.tools !== undefined ? { tools: request.tools.map(toAnthropicTool) } : {}) }),
         });
         if (!response.ok)
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text(), response.headers);
@@ -471,6 +567,8 @@ export class AnthropicModelProvider {
         if (this.rateLimiter)
             await this.rateLimiter.acquire(this.rateLimitKey, request.signal ? { signal: request.signal } : undefined);
         const { system, messages } = toAnthropicMessages(request.messages);
+        const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel) ? anthropicThinkingBudget(request.thinkingLevel) : undefined;
+        const maxTokens = thinkingBudget !== undefined ? Math.max(this.maxTokens, thinkingBudget + 1024) : this.maxTokens;
         const response = await fetch(`${this.baseUrl}/messages`, {
             method: 'POST',
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
@@ -484,7 +582,8 @@ export class AnthropicModelProvider {
             body: JSON.stringify({
                 model,
                 stream: true,
-                max_tokens: this.maxTokens,
+                max_tokens: maxTokens,
+                ...(thinkingBudget !== undefined ? { thinking: { type: 'enabled', budget_tokens: thinkingBudget } } : {}),
                 ...(system ? { system } : {}),
                 messages,
                 ...(request.tools !== undefined ? { tools: request.tools.map(toAnthropicTool) } : {}),
@@ -599,19 +698,44 @@ function estimateUsage(messages) {
     const chars = messages.reduce((sum, message) => sum + message.content.length, 0);
     return { totalTokens: Math.ceil(chars / 4) };
 }
-function retryDelay(baseMs, attempt) {
-    return Math.min(30_000, Math.round(baseMs * 2 ** Math.max(0, attempt - 1)));
+function calculateRetryDelay(baseMs, attempt) {
+    const baseDelay = baseMs * 2 ** (attempt - 1);
+    const jittered = baseDelay * (0.75 + Math.random() * 0.5);
+    return Math.round(jittered);
 }
 function isRetryableModelError(error) {
     if (error instanceof ProviderHttpError)
         return error.status === 429 || error.status >= 500;
     if (error instanceof Error && error.name === 'AbortError')
         return false;
-    return true;
+    const message = error instanceof Error ? error.message : String(error);
+    return /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|network.?error|connection.?(?:reset|refused|lost)|socket hang up|fetch failed|timed? out|timeout|terminated/i.test(message);
 }
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function sleepWithAbort(ms, signal) {
+    if (signal.aborted)
+        return Promise.reject(createAbortError(signal.reason));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            reject(createAbortError(signal.reason));
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function createAbortError(reason) {
+    const message = reason instanceof Error ? reason.message : typeof reason === 'string' ? reason : 'This operation was aborted';
+    const err = new Error(message);
+    err.name = 'AbortError';
+    return err;
+}
 export function toOpenAIMessage(message) {
     if (message.role === 'tool') {
         return { role: 'tool', tool_call_id: message.toolCallId ?? message.name ?? 'tool', content: message.content };
@@ -701,7 +825,7 @@ function toAnthropicMessages(messages) {
     });
     return { ...(system ? { system } : {}), messages: converted };
 }
-function toGeminiRequest(request) {
+function toGeminiRequest(request, model) {
     const system = request.messages.filter((message) => message.role === 'system').map((message) => message.content).join('\n\n');
     const contents = request.messages.filter((message) => message.role !== 'system').map((message) => {
         if (message.role === 'tool')
@@ -710,10 +834,12 @@ function toGeminiRequest(request) {
             return { role: 'model', parts: message.toolCalls.map((call) => ({ functionCall: { name: call.name, args: call.input ?? {} } })) };
         return { role: message.role === 'assistant' ? 'model' : 'user', parts: [{ text: message.content }] };
     });
+    const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel) ? geminiThinkingBudget(request.thinkingLevel) : undefined;
     return {
         ...(system ? { systemInstruction: { parts: [{ text: system }] } } : {}),
         contents,
         ...(request.tools?.length ? { tools: [{ functionDeclarations: request.tools.map(toGeminiTool) }] } : {}),
+        ...(thinkingBudget !== undefined ? { generationConfig: { thinkingConfig: { thinkingBudget } } } : {}),
     };
 }
 function toGeminiTool(tool) {
@@ -758,6 +884,7 @@ function toBedrockRequest(request) {
         ...(system.length ? { system } : {}),
         messages,
         ...(request.tools?.length ? { toolConfig: { tools: request.tools.map(toBedrockTool) } } : {}),
+        ...(request.sessionId !== undefined ? { sessionId: request.sessionId } : {}),
     };
 }
 function toBedrockTool(tool) {
@@ -858,6 +985,48 @@ function safeJsonParse(value) {
         return undefined;
     }
 }
+/**
+ * Split a string into lines handling LF (`\n`), CRLF (`\r\n`), and CR-only
+ * (`\r`) line endings. When a buffer ends with `\r` and the next chunk starts
+ * with `\n`, the pair is treated as a single CRLF and no empty line is emitted.
+ *
+ * @param buffer    The text accumulated so far.
+ * @param pendingCR `true` when the previous chunk ended with a bare `\r`.
+ * @returns Lines found in the buffer, the updated `pendingCR` flag, and the
+ *          unprocessed remainder to carry into the next chunk.
+ */
+function splitLines(buffer, pendingCR) {
+    const lines = [];
+    let start = 0;
+    let pending = false;
+    // If previous chunk ended with \r and this one starts with \n, skip the \n
+    // as it completes a split CRLF sequence.
+    if (pendingCR && buffer.length > 0 && buffer[0] === '\n') {
+        start = 1;
+    }
+    for (let i = start; i < buffer.length; i++) {
+        const ch = buffer[i];
+        if (ch === '\n') {
+            lines.push(buffer.slice(start, i));
+            start = i + 1;
+        }
+        else if (ch === '\r') {
+            if (i + 1 < buffer.length && buffer[i + 1] === '\n') {
+                // CRLF within the same buffer
+                lines.push(buffer.slice(start, i));
+                i++; // skip the \n
+                start = i + 1;
+            }
+            else {
+                // CR-only or the first half of a CRLF split across chunks
+                lines.push(buffer.slice(start, i));
+                pending = true;
+                start = i + 1;
+            }
+        }
+    }
+    return { lines, pendingCR: pending, remainder: buffer.slice(start) };
+}
 /**
  * Decode an OpenAI-style SSE stream — yields the JSON payload from each
  * `data: ...` line. Yields the literal sentinel `[DONE]` when the stream ends.
@@ -866,21 +1035,22 @@ async function* decodeOpenAISSE(stream) {
     const decoder = new TextDecoder();
     const reader = stream.getReader();
     let buffer = '';
+    let pendingCR = false;
     try {
         while (true) {
             const { value, done } = await reader.read();
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });
-            let nl = buffer.indexOf('\n');
-            while (nl >= 0) {
-                const line = buffer.slice(0, nl).trim();
-                buffer = buffer.slice(nl + 1);
-                nl = buffer.indexOf('\n');
-                if (!line || line.startsWith(':'))
+            const { lines, pendingCR: newPendingCR, remainder } = splitLines(buffer, pendingCR);
+            pendingCR = newPendingCR;
+            buffer = remainder;
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith(':'))
                     continue;
-                if (line.startsWith('data:')) {
-                    const payload = line.slice(5).trim();
+                if (trimmed.startsWith('data:')) {
+                    const payload = trimmed.slice(5).trim();
                     if (!payload)
                         continue;
                     yield payload;
@@ -901,27 +1071,28 @@ async function* decodeAnthropicSSE(stream) {
     const reader = stream.getReader();
     let buffer = '';
     let pendingEvent;
+    let pendingCR = false;
     try {
         while (true) {
             const { value, done } = await reader.read();
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });
-            let nl = buffer.indexOf('\n');
-            while (nl >= 0) {
-                const line = buffer.slice(0, nl).trim();
-                buffer = buffer.slice(nl + 1);
-                nl = buffer.indexOf('\n');
-                if (!line) {
+            const { lines, pendingCR: newPendingCR, remainder } = splitLines(buffer, pendingCR);
+            pendingCR = newPendingCR;
+            buffer = remainder;
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed) {
                     pendingEvent = undefined;
                     continue;
                 }
-                if (line.startsWith('event:')) {
-                    pendingEvent = line.slice(6).trim();
+                if (trimmed.startsWith('event:')) {
+                    pendingEvent = trimmed.slice(6).trim();
                     continue;
                 }
-                if (line.startsWith('data:')) {
-                    const payload = line.slice(5).trim();
+                if (trimmed.startsWith('data:')) {
+                    const payload = trimmed.slice(5).trim();
                     if (!payload)
                         continue;
                     const parsed = safeJsonParse(payload);