loopengine 0.2.0 → 0.2.2

package/dist/core/agent-config.d.ts

@@ -273,16 +273,18 @@ export type AgentModelConfig = {
     model?: string;
     apiKey?: string;
     maxTokens?: number;
+    /** How much Claude thinks before answering; omitted, the model's own
+     * default. See AnthropicModelCallOptions.reasoningEffort
+     * (core/model-calls/anthropic-model-call.ts). */
+    reasoningEffort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 } | {
     provider: 'openai';
     model: string;
     apiKey?: string;
     maxTokens?: number;
-    /** Omit unless the model actually needs it — see
-     * OpenAIModelCallOptions.reasoningEffort's own doc comment
-     * (core/model-calls/openai-model-call.ts) for why a reasoning-
-     * capable model (gpt-5.x) can require this be `'none'` just to use
-     * function tools at all. */
+    /** How much the model reasons before answering; omitted, the
+     * model's own default. See OpenAIModelCallOptions.reasoningEffort
+     * (core/model-calls/openai-model-call.ts). */
     reasoningEffort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 } | {
     provider: 'deepseek';

package/dist/core/model-calls/anthropic-model-call.d.ts

@@ -4,7 +4,14 @@ export interface AnthropicModelCallOptions {
     /** Defaults to the ANTHROPIC_API_KEY env var, same as the SDK itself. */
     apiKey?: string;
     model?: string;
+    /** Defaults to 4096, or 16000 with a reasoning effort set: thinking
+     * counts toward it. */
     maxTokens?: number;
+    /** How much Claude thinks before answering. 'none' turns thinking off;
+     * 'minimal' and 'low' to 'max' turn on adaptive thinking at that effort
+     * (Claude has no 'minimal', so it means 'low'). Omitted, the model's
+     * own default. */
+    reasoningEffort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     /** Inject a pre-configured client instead of building one from apiKey — e.g. to pass a custom `fetch` in tests. */
     client?: Anthropic;
 }

package/dist/core/model-calls/anthropic-model-call.js

@@ -13,7 +13,24 @@
 // Anthropic's own API expects a tool_use to be answered by a matching
 // tool_result. This file's only job is translating between that shape and
 // the SDK's own param/response types — see message-to-param below.
+//
+// With a reasoning effort set, Claude thinks before answering (adaptive
+// thinking at that effort), and its thinking blocks come back signed. The
+// API needs them sent back unchanged with the tool results they led to,
+// so each rides in the conversation as an 'anthropic_thinking' block (the
+// whole block as JSON in `data`), sent back only to Anthropic.
 import Anthropic from '@anthropic-ai/sdk';
+/** The thinking (or redacted thinking) block an 'anthropic_thinking'
+ * block carries, or undefined if its data isn't one. */
+function thinkingBlockParam(block) {
+    try {
+        const parsed = JSON.parse(block.data ?? '');
+        return parsed && (parsed.type === 'thinking' || parsed.type === 'redacted_thinking') ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function toContentBlockParam(block) {
     if (block.type === 'tool_use') {
         return { type: 'tool_use', id: block.id, name: block.name, input: block.input ?? {} };
@@ -29,13 +46,27 @@ function toContentBlockParam(block) {
 function toMessageParam(message) {
     return {
         role: message.role === 'assistant' ? 'assistant' : 'user',
-        content: typeof message.content === 'string' ? message.content : message.content.map(toContentBlockParam),
+        // Claude's own signed thinking goes back as it came. Blocks only
+        // another provider can use (DeepSeek's 'thinking', 'openai_reasoning')
+        // are left out; as text they'd be empty text blocks, which the API
+        // rejects.
+        content: typeof message.content === 'string'
+            ? message.content
+            : message.content.flatMap((block) => {
+                if (block.type === 'anthropic_thinking') {
+                    const thinking = thinkingBlockParam(block);
+                    return thinking ? [thinking] : [];
+                }
+                return ['text', 'tool_use', 'tool_result'].includes(block.type) ? [toContentBlockParam(block)] : [];
+            }),
     };
 }
 export function createAnthropicModelCall(options = {}) {
     const client = options.client ?? new Anthropic({ apiKey: options.apiKey });
     const model = options.model ?? 'claude-sonnet-5';
-    const maxTokens = options.maxTokens ?? 4096;
+    const maxTokens = options.maxTokens ?? (options.reasoningEffort ? 16000 : 4096);
+    const effort = options.reasoningEffort === 'minimal' ? 'low' : options.reasoningEffort;
+    const reasoning = effort === undefined ? {} : effort === 'none' ? { thinking: { type: 'disabled' } } : { thinking: { type: 'adaptive' }, output_config: { effort } };
     return async (messages, system, tools) => {
         const response = await client.messages.create({
             model,
@@ -49,10 +80,13 @@ export function createAnthropicModelCall(options = {}) {
                     input_schema: t.input_schema,
                 }))
                 : undefined,
+            ...reasoning,
         });
         const content = response.content.map((block) => {
             if (block.type === 'text')
                 return { type: 'text', text: block.text };
+            if (block.type === 'thinking' || block.type === 'redacted_thinking')
+                return { type: 'anthropic_thinking', data: JSON.stringify(block) };
             if (block.type === 'tool_use') {
                 return { type: 'tool_use', id: block.id, name: block.name, input: block.input };
             }

package/dist/core/model-calls/openai-model-call.d.ts

@@ -9,16 +9,10 @@ export interface OpenAIModelCallOptions {
      * one you actually want. */
     model: string;
     maxTokens?: number;
-    /** Omitted by default — a reasoning-capable model (the gpt-5.x family)
-     * otherwise gets whatever effort level OpenAI defaults it to, which
-     * some of these models refuse to combine with function tools on
-     * /v1/chat/completions at all ("Function tools with reasoning_effort
-     * are not supported ... set reasoning_effort to 'none'" — confirmed
-     * live against gpt-5.6-luna). Set this to `'none'` for a model that
-     * hits that error; every real loopengine call passes `tools` (even an
-     * empty array is still the `tools` field being present), so there's no
-     * tools-vs-no-tools branch here to get this wrong on. */
-    reasoningEffort?: OpenAI.Chat.Completions.ChatCompletionReasoningEffort;
+    /** How much the model reasons before answering ('none' to 'max');
+     * omitted, the model's own default. Works with tools, since this calls
+     * /v1/responses. */
+    reasoningEffort?: OpenAI.ReasoningEffort;
     /** Inject a pre-configured client instead of building one from apiKey — e.g. to pass a custom `fetch` in tests. */
     client?: OpenAI;
 }
@@ -30,5 +24,15 @@ export declare function parseToolArguments(raw: string): Record<string, unknown>
 export declare function toMessageParams(message: Message): ChatMessage[];
 export declare function toStopReason(finishReason: string): string;
 export declare function toModelResponse(choice: OpenAI.Chat.Completions.ChatCompletion.Choice): ModelResponse;
+type ResponseInputItem = OpenAI.Responses.ResponseInputItem;
+/** One loopengine Message as Responses input items: an assistant turn's
+ * reasoning, text and tool calls in the order the model produced them,
+ * and a user turn's tool results (or text). Another provider's 'thinking'
+ * blocks are dropped: OpenAI can't use them. */
+export declare function toResponsesInput(message: Message): ResponseInputItem[];
+/** A Response as a ModelResponse: reasoning items as 'openai_reasoning'
+ * blocks, message text, and function calls as tool_use blocks (their
+ * call_id is the id a tool result answers). */
+export declare function fromResponse(response: OpenAI.Responses.Response): ModelResponse;
 export declare function createOpenAIModelCall(options: OpenAIModelCallOptions): ModelCall;
 export {};

package/dist/core/model-calls/openai-model-call.js

@@ -3,6 +3,20 @@
 // the canned fake in any agent and nothing in run-agent.ts, the adapters,
 // or any AgentConfig changes.
 //
+// createOpenAIModelCall calls OpenAI's Responses API (/v1/responses):
+// OpenAI's reasoning models refuse function tools together with any
+// reasoning effort on /v1/chat/completions (every gpt-5.4 to gpt-6.1 model
+// checked live, Nov 2026), so an agent with tools could only run them with
+// reasoning off there. The Chat Completions translation below
+// (toMessageParams/toStopReason/toModelResponse) stays for the
+// OpenAI-compatible providers that reuse it.
+//
+// Responses is called statelessly (store: false): loopengine keeps the
+// conversation itself, so each reasoning item comes back encrypted, rides
+// in the conversation as an 'openai_reasoning' block, and is sent back
+// with the tool results it led to, which the API needs to carry the
+// model's reasoning across tool calls.
+//
 // Structural mismatch worth knowing: loopengine's Message bundles every
 // tool_result from one turn into a single user-role message's content
 // array (mirroring Anthropic's own shape, which this framework's Message
@@ -152,23 +166,89 @@ export function toModelResponse(choice) {
     }
     return { stop_reason: toStopReason(choice.finish_reason), content };
 }
+/** The reasoning item an 'openai_reasoning' block carries, or undefined if
+ * its data isn't one (it is sent back only as OpenAI returned it). */
+function reasoningItem(block) {
+    try {
+        const item = JSON.parse(block.data ?? '');
+        return item && item.type === 'reasoning' ? item : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** One loopengine Message as Responses input items: an assistant turn's
+ * reasoning, text and tool calls in the order the model produced them,
+ * and a user turn's tool results (or text). Another provider's 'thinking'
+ * blocks are dropped: OpenAI can't use them. */
+export function toResponsesInput(message) {
+    const role = message.role === 'assistant' ? 'assistant' : 'user';
+    if (typeof message.content === 'string')
+        return [{ role, content: message.content }];
+    const items = [];
+    for (const block of message.content) {
+        if (block.type === 'openai_reasoning') {
+            const item = reasoningItem(block);
+            if (item)
+                items.push(item);
+        }
+        else if (block.type === 'tool_use') {
+            items.push({ type: 'function_call', call_id: block.id, name: block.name, arguments: JSON.stringify(block.input ?? {}) });
+        }
+        else if (block.type === 'tool_result') {
+            items.push({ type: 'function_call_output', call_id: block.tool_use_id, output: block.content ?? '' });
+        }
+        else if (block.type === 'text' && block.text) {
+            items.push({ role, content: block.text });
+        }
+    }
+    return items;
+}
+/** A Response as a ModelResponse: reasoning items as 'openai_reasoning'
+ * blocks, message text, and function calls as tool_use blocks (their
+ * call_id is the id a tool result answers). */
+export function fromResponse(response) {
+    const content = [];
+    let calledTools = false;
+    for (const item of response.output) {
+        if (item.type === 'reasoning') {
+            content.push({ type: 'openai_reasoning', data: JSON.stringify(item) });
+        }
+        else if (item.type === 'message') {
+            const text = item.content.map((part) => (part.type === 'output_text' ? part.text : part.refusal)).join('');
+            if (text)
+                content.push({ type: 'text', text });
+        }
+        else if (item.type === 'function_call') {
+            calledTools = true;
+            content.push({ type: 'tool_use', id: item.call_id, name: item.name, input: parseToolArguments(item.arguments) });
+        }
+    }
+    const stop_reason = calledTools
+        ? 'tool_use'
+        : response.status === 'incomplete' && response.incomplete_details?.reason === 'max_output_tokens'
+            ? 'max_tokens'
+            : 'end_turn';
+    const usage = response.usage ? { input_tokens: response.usage.input_tokens, output_tokens: response.usage.output_tokens } : undefined;
+    return { stop_reason, content, ...(usage ? { usage } : {}) };
+}
 export function createOpenAIModelCall(options) {
     const client = options.client ?? new OpenAI({ apiKey: options.apiKey });
-    const maxTokens = options.maxTokens ?? 4096;
+    // Reasoning counts toward max_output_tokens.
+    const maxTokens = options.maxTokens ?? (options.reasoningEffort && options.reasoningEffort !== 'none' ? 16000 : 4096);
     return async (messages, system, tools) => {
-        const response = await client.chat.completions.create({
+        const response = await client.responses.create({
             model: options.model,
-            max_completion_tokens: maxTokens,
-            messages: [{ role: 'system', content: system }, ...messages.flatMap(toMessageParams)],
+            instructions: system,
+            input: messages.flatMap(toResponsesInput),
+            max_output_tokens: maxTokens,
             tools: tools.length
-                ? tools.map((t) => ({
-                    type: 'function',
-                    function: { name: t.name, description: t.description, parameters: t.input_schema },
-                }))
+                ? tools.map((t) => ({ type: 'function', name: t.name, description: t.description, parameters: t.input_schema, strict: false }))
                 : undefined,
-            reasoning_effort: options.reasoningEffort,
+            ...(options.reasoningEffort ? { reasoning: { effort: options.reasoningEffort } } : {}),
+            store: false,
+            include: ['reasoning.encrypted_content'],
         });
-        const usage = response.usage ? { input_tokens: response.usage.prompt_tokens, output_tokens: response.usage.completion_tokens } : undefined;
-        return { ...toModelResponse(response.choices[0]), usage };
+        return fromResponse(response);
     };
 }

package/dist/core/run-agent.d.ts

@@ -33,6 +33,10 @@ export interface ModelContentBlock {
     content?: string;
     /** tool_result blocks: true if the tool call failed or was denied. */
     is_error?: boolean;
+    /** Provider data carried opaquely and sent back to the same provider,
+     * e.g. an 'openai_reasoning' block's encrypted reasoning item (see
+     * model-calls/openai-model-call.ts). Never shown to a model as text. */
+    data?: string;
     /** tool_result blocks: the actauth decision's own reason this call was
      * allowed (e.g. "matched rule '...'"). Extra metadata riding alongside
      * `content`, not folded into it — every model-calls/* adapter

package/dist/web/agent-file-admin.d.ts

@@ -3,6 +3,8 @@ export declare class AgentEditNotSupportedError extends Error {
 export declare class AgentFileNotFoundError extends Error {
 }
 type Provider = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'glm' | 'gemini' | 'xai' | 'meta';
+/** The providers whose model calls take a reasoning effort. */
+export declare const REASONING_PROVIDERS: Provider[];
 export interface AgentEditableFields {
     systemPrompt?: string;
     model?: {

package/dist/web/agent-file-admin.js

@@ -48,6 +48,8 @@ export class AgentEditNotSupportedError extends Error {
 }
 export class AgentFileNotFoundError extends Error {
 }
+/** The providers whose model calls take a reasoning effort. */
+export const REASONING_PROVIDERS = ['openai', 'anthropic'];
 const MODEL_ENV_VAR = {
     anthropic: 'ANTHROPIC_API_KEY',
     openai: 'OPENAI_API_KEY',
@@ -178,12 +180,12 @@ export function editAgentFile(agentName, fields) {
             throw new AgentEditNotSupportedError('model.maxTokens must be a positive integer.');
         }
         const reasoningEffort = fields.model.reasoningEffort;
-        // Only AgentModelConfig's 'openai' variant carries this (see its own
-        // doc comment) — refusing rather than silently dropping it for
-        // another provider, same "don't guess" posture the model-name check
-        // right above already follows.
-        if (reasoningEffort !== undefined && provider !== 'openai') {
-            throw new AgentModelError(`model.reasoningEffort only applies to provider 'openai' — '${provider}' doesn't support it.`);
+        // Only AgentModelConfig's 'openai' and 'anthropic' variants carry this
+        // (see their doc comments) — refusing rather than silently dropping it
+        // for another provider, same "don't guess" posture the model-name
+        // check right above already follows.
+        if (reasoningEffort !== undefined && !REASONING_PROVIDERS.includes(provider)) {
+            throw new AgentModelError(`model.reasoningEffort only applies to providers ${REASONING_PROVIDERS.join(' and ')} — '${provider}' doesn't support it.`);
         }
         // Every field the form actually round-trips (not just provider/model)
         // — omitting maxTokens/reasoningEffort here, the way this used to

package/dist/web/agents-config-page.js

@@ -28,6 +28,7 @@
 import { devUiCss } from './dev-ui-styles.js';
 import { MESSAGING_ICONS } from './messaging-icons.js';
 import { consoleShellScript, consoleSidebarHtml } from './console-shell.js';
+import { REASONING_PROVIDERS } from './agent-file-admin.js';
 export const agentsConfigPageHtml = `<!doctype html>
 <html lang="en">
 <head>
@@ -358,6 +359,8 @@ ${consoleSidebarHtml}
 ${consoleShellScript}
 <script>
 (function () {
+  // The providers whose models take a reasoning effort (web/agent-file-admin.ts).
+  var REASONING_PROVIDERS = ${JSON.stringify(REASONING_PROVIDERS)};
   var empty = document.getElementById('empty');
   var detail = document.getElementById('detail');
   var currentName = null;
@@ -792,7 +795,7 @@ ${consoleShellScript}
           '<dt>Provider</dt><dd>' + escapeHtml(cfg.model.provider) + '</dd>' +
           '<dt>Model</dt><dd>' + escapeHtml(cfg.model.model || '(provider default)') + '</dd>' +
           '<dt>Max tokens</dt><dd>' + escapeHtml(cfg.model.maxTokens != null ? cfg.model.maxTokens : '(default)') + '</dd>' +
-          '<dt>Reasoning effort</dt><dd>' + escapeHtml(cfg.model.reasoningEffort || (cfg.model.provider === 'openai' ? '(provider default)' : 'n/a')) + '</dd>' +
+          '<dt>Reasoning effort</dt><dd>' + escapeHtml(cfg.model.reasoningEffort || (REASONING_PROVIDERS.indexOf(cfg.model.provider) !== -1 ? '(model default)' : 'n/a')) + '</dd>' +
         '</dl>' +
         '<form class="add-source" id="modelForm" style="display:none">' +
           '<label>Provider' +
@@ -808,7 +811,7 @@ ${consoleShellScript}
           '<label>Max tokens <span class="hint">(blank for provider default)</span>' +
             '<input type="number" name="maxTokens" min="1" step="1" value="' + (cfg.model.maxTokens != null ? escapeHtml(cfg.model.maxTokens) : '') + '">' +
           '</label>' +
-          '<label>Reasoning effort <span class="hint">(openai only — some reasoning models reject function tools unless this is \\\'none\\\'; leave unset otherwise)</span>' +
+          '<label id="reasoningEffortField">Reasoning effort <span class="hint">(how much the model thinks before answering: none turns it off, unset uses the model\\\'s default)</span>' +
             '<select name="reasoningEffort">' +
               ['', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].map(function (v) {
                 return '<option value="' + v + '"' + (v === (cfg.model.reasoningEffort || '') ? ' selected' : '') + '>' + (v || '(unset)') + '</option>';
@@ -918,7 +921,19 @@ ${consoleShellScript}
       var modelForm = overviewPanel.querySelector('#modelForm');
       var modelError = overviewPanel.querySelector('#modelError');
 
+      // Only OpenAI and Anthropic models take a reasoning effort: the
+      // field shows for those, and is cleared for any other provider so
+      // it's never saved with one.
+      var providerSelect = modelForm.querySelector('select[name="provider"]');
+      var reasoningField = modelForm.querySelector('#reasoningEffortField');
+      function syncReasoningField() {
+        var supported = REASONING_PROVIDERS.indexOf(providerSelect.value) !== -1;
+        reasoningField.style.display = supported ? '' : 'none';
+        if (!supported) reasoningField.querySelector('select').value = '';
+      }
+      providerSelect.addEventListener('change', syncReasoningField);
       editModelBtn.addEventListener('click', function () {
+        syncReasoningField();
         modelDisplay.style.display = 'none';
         editModelBtn.style.display = 'none';
         modelForm.style.display = '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",