loopengine 0.1.44 → 0.1.46

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

@@ -252,6 +252,12 @@ export type AgentModelConfig = {
     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. */
+    reasoningEffort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 } | {
     provider: 'deepseek';
     model: string;

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

@@ -9,6 +9,16 @@ 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;
     /** Inject a pre-configured client instead of building one from apiKey — e.g. to pass a custom `fetch` in tests. */
     client?: OpenAI;
 }

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

@@ -120,6 +120,7 @@ export function createOpenAIModelCall(options) {
                     function: { name: t.name, description: t.description, parameters: t.input_schema },
                 }))
                 : undefined,
+            reasoning_effort: options.reasoningEffort,
         });
         return toModelResponse(response.choices[0]);
     };

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

@@ -8,6 +8,8 @@ export interface AgentEditableFields {
     model?: {
         provider: Provider;
         model?: string;
+        maxTokens?: number;
+        reasoningEffort?: string;
     };
     maxTurns?: number;
     contextBudgetTokens?: number;
@@ -18,6 +20,8 @@ export interface AgentEditResult {
     model?: {
         provider: Provider;
         model: string;
+        maxTokens?: number;
+        reasoningEffort?: string;
     };
     maxTurns?: number;
     contextBudgetTokens?: number;

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

@@ -162,12 +162,34 @@ export function editAgentFile(agentName, fields) {
         if (provider !== 'anthropic' && !modelName) {
             throw new AgentModelError(`A model name is required for provider '${provider}' — only anthropic has a default (claude-sonnet-5).`);
         }
+        const maxTokens = fields.model.maxTokens;
+        if (maxTokens !== undefined && (!Number.isInteger(maxTokens) || maxTokens < 1)) {
+            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.`);
+        }
+        // Every field the form actually round-trips (not just provider/model)
+        // — omitting maxTokens/reasoningEffort here, the way this used to
+        // unconditionally build `{ provider, model }` alone, would silently
+        // wipe out a value that was already set the moment an operator
+        // changed anything else about the model through this same form.
+        const objectFields = [`provider: '${provider}'`, `model: ${tsStringLiteral(modelName)}`];
+        if (maxTokens !== undefined)
+            objectFields.push(`maxTokens: ${maxTokens}`);
+        if (reasoningEffort !== undefined)
+            objectFields.push(`reasoningEffort: ${tsStringLiteral(reasoningEffort)}`);
         edits.push({
             start: prop.initializer.getStart(sourceFile),
             end: prop.initializer.getEnd(),
-            text: `{ provider: '${provider}', model: ${tsStringLiteral(modelName)} }`,
+            text: `{ ${objectFields.join(', ')} }`,
         });
-        result.model = { provider, model: modelName };
+        result.model = { provider, model: modelName, maxTokens, reasoningEffort };
         // The property's own value is now correct, but a stale
         // "// reads ANTHROPIC_API_KEY" sitting right after it (from before a
         // provider change) would be actively misleading, not just cosmetic —

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

@@ -658,6 +658,7 @@ export const agentsConfigPageHtml = `<!doctype html>
           '<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>' +
         '</dl>' +
         '<form class="add-source" id="modelForm" style="display:none">' +
           '<label>Provider' +
@@ -670,6 +671,16 @@ export const agentsConfigPageHtml = `<!doctype html>
           '<label>Model name <span class="hint">(required for openai/deepseek; defaults to claude-sonnet-5 for anthropic)</span>' +
             '<input type="text" name="modelName" value="' + escapeHtml(cfg.model.model || '') + '">' +
           '</label>' +
+          '<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>' +
+            '<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>';
+              }).join('') +
+            '</select>' +
+          '</label>' +
           '<button type="submit">Save</button>' +
           '<button type="button" id="cancelModelBtn">Cancel</button>' +
           '<div class="error" id="modelError"></div>' +
@@ -793,6 +804,10 @@ export const agentsConfigPageHtml = `<!doctype html>
         var body = { model: { provider: data.get('provider') } };
         var modelName = data.get('modelName');
         if (modelName && modelName.trim()) body.model.model = modelName;
+        var maxTokens = data.get('maxTokens');
+        if (maxTokens && String(maxTokens).trim()) body.model.maxTokens = parseInt(maxTokens, 10);
+        var reasoningEffort = data.get('reasoningEffort');
+        if (reasoningEffort) body.model.reasoningEffort = reasoningEffort;
         fetch('/agents/' + encodeURIComponent(name), {
           method: 'PUT',
           headers: { 'content-type': 'application/json' },

package/package.json

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