loopengine 0.2.1 → 0.2.2

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

@@ -273,6 +273,10 @@ 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;

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,18 +46,27 @@ function toContentBlockParam(block) {
 function toMessageParam(message) {
     return {
         role: message.role === 'assistant' ? 'assistant' : 'user',
-        // Blocks only another provider can use (another model's reasoning:
-        // 'thinking', 'openai_reasoning') are left out; as text they'd be
-        // empty text blocks, which the API rejects.
+        // 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.filter((block) => ['text', 'tool_use', 'tool_result'].includes(block.type)).map(toContentBlockParam),
+            : 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,
@@ -54,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.js

@@ -234,7 +234,8 @@ export function fromResponse(response) {
 }
 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.responses.create({
             model: options.model,

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.1",
+  "version": "0.2.2",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",