@shawnstack/quickforge 1.3.13 → 1.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shawnstack/quickforge",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "AI chat application with YOLO-mode local workspace tools. React + Vite + Tailwind CSS frontend, local Node.js storage server.",
   "keywords": [
     "ai",

package/server/agent-manager.mjs

@@ -2,7 +2,7 @@ import { EventEmitter } from 'node:events'
 import { randomUUID } from 'node:crypto'
 import { Agent } from '@mariozechner/pi-agent-core'
 import { streamSimpleWithAiHttpLogging } from './ai-http-logger.mjs'
-import { toolHandlers, loadSkillToolContext } from './tools/index.mjs'
+import { toolHandlers, loadSkillToolContext, abortRunningCommand } from './tools/index.mjs'
 import { createSkillTools, workspaceTools } from './tools/definitions.mjs'
 import { callMcpTool, createMcpToolDefinitions, isMcpToolName } from './mcp/registry.mjs'
 import { projectContextFromId, readProjectConfig } from './project-config.mjs'
@@ -15,6 +15,10 @@ import {
   parseCompactArgs,
   saveCompactBackup,
 } from './conversation-compaction.mjs'
+import {
+  buildAutoCompactLoopMessages,
+  maybeAutoCompactSession,
+} from './auto-compaction.mjs'
 import {
   handleInternalCommand,
   parseInternalCommandInvocation,
@@ -47,12 +51,13 @@ function wrapToolDefinition(definition, context, toolPermissions) {
 
       const startedAt = Date.now()
       const startedAtPerf = performance.now()
-      const result = await handler(params || {}, context, { signal, onUpdate })
+      const result = await handler(params || {}, context, { signal, onUpdate, toolCallId: _toolCallId })
       const finishedAt = Date.now()
       const durationMs = Math.max(0, Math.round(performance.now() - startedAtPerf))
+      const details = mergeQuickForgeTiming(result.details, { startedAt, finishedAt, durationMs })
       return {
         content: [{ type: 'text', text: result.content }],
-        details: mergeQuickForgeTiming(result.details, { startedAt, finishedAt, durationMs }),
+        details: isPlainObject(details) ? { ...details, toolCallId: _toolCallId } : details,
       }
     },
   }
@@ -137,6 +142,7 @@ const APPROVAL_TIMEOUT_MS = 5 * 60 * 1000 // 5 minutes for tool approval
 const commandRestrictedTools = new Set(['write_file', 'edit_file', 'run_command'])
 const safeReadTools = new Set(['read_file', 'grep_files'])
 const pendingApprovals = new Map() // toolCallId → { resolve, reject, sessionId, toolName, args, timeout }
+const pendingAutoCompactApprovals = new Map() // approvalId → { resolve, reject, sessionId, timeout }
 
 function createCommandToolPermissions(session) {
   return (toolName) => {
@@ -220,6 +226,61 @@ function createApprovalPromise(session, toolCallId, toolName, args) {
   })
 }
 
+function createAutoCompactApprovalPromise(session, details = {}) {
+  if (!session) return Promise.resolve(false)
+  const approvalId = randomUUID()
+  return new Promise((resolve, reject) => {
+    let settled = false
+    const timeout = setTimeout(() => {
+      if (settled) return
+      settled = true
+      pendingAutoCompactApprovals.delete(approvalId)
+      resolve(false)
+    }, APPROVAL_TIMEOUT_MS)
+
+    const cleanup = () => {
+      clearTimeout(timeout)
+      if (settled) return
+      settled = true
+      pendingAutoCompactApprovals.delete(approvalId)
+    }
+
+    const signal = session.agent.signal
+    if (signal) {
+      if (signal.aborted) {
+        cleanup()
+        reject(new Error('Run aborted'))
+        return
+      }
+      const onAbort = () => {
+        cleanup()
+        reject(new Error('Run aborted'))
+      }
+      signal.addEventListener('abort', onAbort, { once: true })
+    }
+
+    pendingAutoCompactApprovals.set(approvalId, {
+      resolve: (approved) => {
+        cleanup()
+        resolve(approved === true)
+      },
+      reject: (err) => {
+        cleanup()
+        reject(err)
+      },
+      sessionId: session.sessionId,
+    })
+
+    emitSessionEvent(session, {
+      type: 'auto_compact_approval_required',
+      approvalId,
+      usage: details.usage,
+      thresholdPercent: details.settings?.thresholdPercent,
+      keepRecentTurns: details.settings?.keepRecentTurns,
+    })
+  })
+}
+
 function assistantTextMessage(text, model) {
   return {
     role: 'assistant',
@@ -294,10 +355,13 @@ function addToolTimingToEvent(session, event) {
 
 function updateSessionMessages(session, messages) {
   session.agent.state.messages = messages
-  const compacted = compactedContextMessages(messages)
-  if (compacted.length < messages.length) {
-    session.agent.state.messages = compacted
-  }
+}
+
+function resetSessionCompaction(session) {
+  session.contextCompaction = null
+  session.lastAutoCompactAt = null
+  session.lastTransformedContextMessages = null
+  session.autoCompacting = false
 }
 
 function finishManualSessionRun(session, status, errorMessage) {
@@ -464,6 +528,7 @@ async function clearSession(session) {
   }
 
   updateSessionMessages(session, [])
+  resetSessionCompaction(session)
   session.status = 'idle'
   session.startedAt = null
   session.finishedAt = new Date().toISOString()
@@ -576,8 +641,19 @@ function compactedContextMessages(messages) {
   return index >= 0 ? messages.slice(index) : messages
 }
 
-function transformAgentContext(messages, commandPrompt) {
-  return applyActiveCommandPrompt(compactedContextMessages(messages), commandPrompt)
+async function transformSessionContext(session, messages, signal) {
+  await maybeAutoCompactSession({
+    session,
+    messages,
+    signal,
+    emitSessionEvent,
+    persistSession,
+    logger,
+    confirmAutoCompact: createAutoCompactApprovalPromise,
+  })
+  const transformedMessages = buildAutoCompactLoopMessages(session, messages)
+  session.lastTransformedContextMessages = transformedMessages
+  return applyActiveCommandPrompt(compactedContextMessages(transformedMessages), session?.activeCommandPrompt)
 }
 
 export const agentEvents = new EventEmitter()
@@ -633,6 +709,7 @@ export async function createAgent(sessionId, config = {}) {
     systemPrompt = null,
     title = 'New chat',
     createdAt = new Date().toISOString(),
+    contextCompaction = null,
   } = config
 
   // Resolve project context for tool calls
@@ -704,9 +781,9 @@ export async function createAgent(sessionId, config = {}) {
     sessionId,
     convertToLlm: serverConvertToLlm,
     onPayload: (payload) => {
-      restoreReasoningContentInPayload(payload, agent.state.messages, agent.state.model)
+      restoreReasoningContentInPayload(payload, session?.lastTransformedContextMessages || agent.state.messages, agent.state.model)
     },
-    transformContext: (messages) => transformAgentContext(messages, session?.activeCommandPrompt),
+    transformContext: (messages, signal) => transformSessionContext(session, messages, signal),
     beforeToolCall: async (context) => {
       const toolName = context.toolCall?.name
       const toolCallId = context.toolCall?.id
@@ -756,6 +833,10 @@ export async function createAgent(sessionId, config = {}) {
     titleGenerated: false,
     toolTimings: new Map(),
     getApiKey,
+    contextCompaction,
+    lastTransformedContextMessages: null,
+    autoCompacting: false,
+    lastAutoCompactAt: null,
     /** Track active SSE connections. Only one SSE stream allowed per session to prevent
      *  connection-pool exhaustion when two browser tabs load the same session. */
     sseConnected: false,
@@ -816,8 +897,8 @@ export async function createAgent(sessionId, config = {}) {
  * Persist session data to storage.
  */
 async function persistSession(session) {
-  const { sessionId, agent, scope, projectId, title, createdAt, status, startedAt, finishedAt, model, thinkingLevel, yoloMode } = session
-  const messages = compactedContextMessages(agent.state.messages)
+  const { sessionId, agent, scope, projectId, title, createdAt, status, startedAt, finishedAt, model, thinkingLevel, yoloMode, contextCompaction } = session
+  const messages = agent.state.messages
 
   if (messages.length === 0) {
     try {
@@ -847,6 +928,7 @@ async function persistSession(session) {
     taskStatus: status,
     taskStartedAt: startedAt,
     taskFinishedAt: finishedAt,
+    contextCompaction: contextCompaction || undefined,
   }
 
   // Calculate usage
@@ -894,6 +976,13 @@ async function persistSession(session) {
     taskStatus: status,
     taskStartedAt: startedAt,
     taskFinishedAt: finishedAt,
+    contextCompaction: contextCompaction ? {
+      compactedAt: contextCompaction.compactedAt,
+      compactedUpToIndex: contextCompaction.compactedUpToIndex,
+      keepRecentTurns: contextCompaction.keepRecentTurns,
+      thresholdPercent: contextCompaction.thresholdPercent,
+      usageBefore: contextCompaction.usageBefore,
+    } : undefined,
   }
 
   // Write to storage atomically (read-modify-write within queue)
@@ -947,6 +1036,7 @@ export async function rollbackSessionMessages(sessionId, rollbackMessageIndex) {
 
   const nextMessages = messages.slice(0, rollbackIndex)
   updateSessionMessages(session, nextMessages)
+  resetSessionCompaction(session)
   session.status = 'idle'
   session.finishedAt = new Date().toISOString()
   await persistSession(session)
@@ -971,6 +1061,7 @@ export async function replaceSessionMessages(sessionId, messages) {
     throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes before rolling back.'), { statusCode: 409 })
   }
   updateSessionMessages(session, Array.isArray(messages) ? messages : [])
+  resetSessionCompaction(session)
   session.status = 'idle'
   session.finishedAt = new Date().toISOString()
   await persistSession(session)
@@ -1083,6 +1174,12 @@ export async function abortRun(sessionId) {
       approval.reject(new Error('Run aborted'))
     }
   }
+  for (const [approvalId, approval] of pendingAutoCompactApprovals) {
+    if (approval.sessionId === sessionId) {
+      approval.reject(new Error('Run aborted'))
+      pendingAutoCompactApprovals.delete(approvalId)
+    }
+  }
 
   session.agent.abort()
   await session.agent.waitForIdle()
@@ -1160,6 +1257,7 @@ export function getSessionState(sessionId) {
     finishedAt: session.finishedAt,
     tools: session.agent.state.tools,
     messages: session.agent.state.messages,
+    contextCompaction: session.contextCompaction,
     isStreaming: session.agent.state.isStreaming,
     errorMessage: session.agent.state.errorMessage,
   }
@@ -1255,6 +1353,7 @@ export async function restoreAgent(sessionId) {
       messages: sessionData.messages || [],
       title: sessionData.title || 'New chat',
       createdAt: sessionData.createdAt,
+      contextCompaction: sessionData.contextCompaction || null,
     })
   } catch (err) {
     logger.error(`Failed to restore agent ${sessionId}:`, err, { sessionId })
@@ -1286,6 +1385,36 @@ export function rejectToolCall(sessionId, toolCallId) {
   return { rejected: true, toolCallId }
 }
 
+export function approveAutoCompact(sessionId, approvalId) {
+  const approval = pendingAutoCompactApprovals.get(approvalId)
+  if (!approval || approval.sessionId !== sessionId) {
+    throw Object.assign(new Error('No pending auto compact approval for this session'), { statusCode: 404 })
+  }
+  approval.resolve(true)
+  return { approved: true, approvalId }
+}
+
+export function rejectAutoCompact(sessionId, approvalId) {
+  const approval = pendingAutoCompactApprovals.get(approvalId)
+  if (!approval || approval.sessionId !== sessionId) {
+    throw Object.assign(new Error('No pending auto compact approval for this session'), { statusCode: 404 })
+  }
+  approval.resolve(false)
+  return { rejected: true, approvalId }
+}
+
+export function abortToolCall(sessionId, toolCallId) {
+  const session = agentSessions.get(sessionId)
+  if (!session) {
+    throw Object.assign(new Error('Session not found'), { statusCode: 404 })
+  }
+  const aborted = abortRunningCommand(toolCallId)
+  if (!aborted) {
+    throw Object.assign(new Error('No running command for this tool call'), { statusCode: 404 })
+  }
+  return { aborted: true, toolCallId }
+}
+
 /**
  * List all active sessions.
  */

package/server/auto-compaction.mjs

@@ -0,0 +1,249 @@
+import { readStore } from './storage.mjs'
+import { compactConversation, saveCompactBackup } from './conversation-compaction.mjs'
+
+export const AUTO_COMPACT_SETTINGS_KEY = 'auto-compact-settings'
+
+export const DEFAULT_AUTO_COMPACT_SETTINGS = {
+  enabled: false,
+  thresholdPercent: 80,
+  keepRecentTurns: 2,
+  minSourceChars: 1600,
+  requireConfirmation: true,
+}
+
+const AUTO_COMPACT_MIN_INTERVAL_MS = 30_000
+
+function clampNumber(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.min(max, Math.max(min, Math.round(parsed)))
+}
+
+export function normalizeAutoCompactSettings(value) {
+  if (!value || typeof value !== 'object') return { ...DEFAULT_AUTO_COMPACT_SETTINGS }
+  return {
+    enabled: value.enabled === true,
+    thresholdPercent: clampNumber(value.thresholdPercent, DEFAULT_AUTO_COMPACT_SETTINGS.thresholdPercent, 50, 95),
+    keepRecentTurns: clampNumber(value.keepRecentTurns, DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns, 1, 20),
+    minSourceChars: clampNumber(value.minSourceChars, DEFAULT_AUTO_COMPACT_SETTINGS.minSourceChars, 0, 200000),
+    requireConfirmation: value.requireConfirmation !== false,
+  }
+}
+
+export async function readAutoCompactSettings() {
+  const settings = await readStore('settings')
+  return normalizeAutoCompactSettings(settings?.[AUTO_COMPACT_SETTINGS_KEY])
+}
+
+function safeJson(value) {
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return ''
+  }
+}
+
+function estimateTextTokens(value) {
+  const text = String(value || '')
+  if (!text) return 0
+  const cjkChars = text.match(/[\u3400-\u9fff\uf900-\ufaff]/g)?.length ?? 0
+  const otherChars = Math.max(0, text.length - cjkChars)
+  return Math.ceil(cjkChars + otherChars / 3.5)
+}
+
+function contentToText(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content.map((block) => {
+    if (!block || typeof block !== 'object') return ''
+    if (block.type === 'text') return block.text || ''
+    if (block.type === 'thinking') return block.thinking || ''
+    if (block.type === 'image') return `[image:${block.mimeType || 'unknown'}]`
+    if (block.type === 'toolCall') return `[toolCall:${block.name || 'unknown'}] ${safeJson(block.arguments)}`
+    return safeJson(block)
+  }).filter(Boolean).join('\n')
+}
+
+function estimateMessageTokens(message) {
+  if (!message || typeof message !== 'object') return 0
+  const parts = [message.role || '', contentToText(message.content)]
+  if (message.toolName) parts.push(message.toolName)
+  if (message.toolCallId) parts.push(message.toolCallId)
+  if (message.details !== undefined) parts.push(safeJson(message.details))
+  if (message.attachments !== undefined) parts.push(safeJson(message.attachments))
+  return estimateTextTokens(parts.join('\n'))
+}
+
+function estimateMessagesTokens(messages) {
+  return (Array.isArray(messages) ? messages : []).reduce((total, message) => total + estimateMessageTokens(message), 0)
+}
+
+function estimateMessagesChars(messages) {
+  return (Array.isArray(messages) ? messages : []).reduce((total, message) => {
+    if (!message || typeof message !== 'object') return total
+    return total + [message.role || '', contentToText(message.content), safeJson(message.details), safeJson(message.attachments)].join('\n').length
+  }, 0)
+}
+
+export function estimateContextUsage({ systemPrompt, messages, tools, model }) {
+  const contextWindow = Number(model?.contextWindow) || 0
+  const reservedOutputTokens = Math.max(0, Number(model?.maxTokens) || 4096)
+  const inputTokens =
+    estimateTextTokens(systemPrompt) +
+    estimateMessagesTokens(messages) +
+    estimateTextTokens(safeJson(tools))
+  const totalTokens = inputTokens + reservedOutputTokens
+  const percent = contextWindow > 0 ? Math.round((totalTokens / contextWindow) * 1000) / 10 : 0
+  return { inputTokens, reservedOutputTokens, totalTokens, contextWindow, percent }
+}
+
+function isUserMessage(message) {
+  return message?.role === 'user' || message?.role === 'user-with-attachments'
+}
+
+function tailStartForRecentTurns(messages, keepRecentTurns) {
+  const source = Array.isArray(messages) ? messages : []
+  let seenUserTurns = 0
+  for (let index = source.length - 1; index >= 0; index--) {
+    if (!isUserMessage(source[index])) continue
+    seenUserTurns += 1
+    if (seenUserTurns >= keepRecentTurns) return index
+  }
+  return 0
+}
+
+function compactSummaryText(message) {
+  const content = message?.content
+  const text = typeof content === 'string'
+    ? content
+    : Array.isArray(content)
+      ? content.filter((block) => block?.type === 'text').map((block) => block.text || '').join('\n')
+      : ''
+  const match = text.match(/<compact_summary>\s*([\s\S]*?)\s*<\/compact_summary>/)
+  return match?.[1]?.trim() || text.trim()
+}
+
+function userTextMessage(text) {
+  return {
+    role: 'user',
+    content: [{ type: 'text', text }],
+    timestamp: Date.now(),
+  }
+}
+
+function buildCompactionSourceMessages(session, messages, tailStart) {
+  const source = []
+  const previousSummary = session.contextCompaction?.summaryMessage
+  if (previousSummary) {
+    source.push(userTextMessage([
+      'Existing rolling compact summary from earlier conversation history:',
+      '',
+      '<compact_summary>',
+      compactSummaryText(previousSummary),
+      '</compact_summary>',
+    ].join('\n')))
+  }
+  source.push(...messages.slice(session.contextCompaction?.compactedUpToIndex || 0, tailStart))
+  return source
+}
+
+export function buildAutoCompactLoopMessages(session, messages) {
+  const summaryMessage = session?.contextCompaction?.summaryMessage
+  if (!summaryMessage) return messages
+  const keepRecentTurns = session.contextCompaction.keepRecentTurns || DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns
+  const tailStart = tailStartForRecentTurns(messages, keepRecentTurns)
+  return [summaryMessage, ...messages.slice(tailStart)]
+}
+
+export async function maybeAutoCompactSession({ session, messages, signal, emitSessionEvent, persistSession, logger, confirmAutoCompact }) {
+  if (!session || session.autoCompacting) return { compacted: false }
+  const settings = await readAutoCompactSettings()
+  if (!settings.enabled) return { compacted: false }
+  if (signal?.aborted) return { compacted: false }
+
+  const loopMessages = buildAutoCompactLoopMessages(session, messages)
+  const usage = estimateContextUsage({
+    systemPrompt: session.agent.state.systemPrompt,
+    messages: loopMessages,
+    tools: session.agent.state.tools,
+    model: session.model,
+  })
+  if (!usage.contextWindow || usage.percent < settings.thresholdPercent) return { compacted: false, usage }
+
+  emitSessionEvent?.(session, {
+    type: 'auto_compact_threshold_reached',
+    usage,
+    thresholdPercent: settings.thresholdPercent,
+    requireConfirmation: settings.requireConfirmation,
+  })
+
+  if (settings.requireConfirmation) {
+    const approved = await confirmAutoCompact?.(session, { usage, settings })
+    if (!approved || signal?.aborted) return { compacted: false, usage, reason: approved === false ? 'user_rejected' : 'confirmation_unavailable' }
+  }
+
+  const now = Date.now()
+  if (session.lastAutoCompactAt && now - session.lastAutoCompactAt < AUTO_COMPACT_MIN_INTERVAL_MS) {
+    return { compacted: false, usage, reason: 'recently_compacted' }
+  }
+  if (session.contextCompaction?.sourceMessageCount && messages.length <= session.contextCompaction.sourceMessageCount + 2) {
+    return { compacted: false, usage, reason: 'not_enough_new_messages' }
+  }
+
+  const tailStart = tailStartForRecentTurns(messages, settings.keepRecentTurns)
+  const sourceMessages = buildCompactionSourceMessages(session, messages, tailStart)
+  if (sourceMessages.length < 2 || estimateMessagesChars(sourceMessages) < settings.minSourceChars) {
+    return { compacted: false, usage, reason: 'not_enough_history' }
+  }
+
+  session.autoCompacting = true
+  try {
+    const result = await compactConversation({
+      messages: sourceMessages,
+      model: session.model,
+      thinkingLevel: session.thinkingLevel,
+      getApiKey: session.getApiKey,
+      keepTurns: 0,
+    })
+
+    if (result.skipped) return { compacted: false, usage, reason: result.reason || 'skipped' }
+
+    await saveCompactBackup(session.sessionId, sourceMessages)
+    const summaryMessage = userTextMessage([
+      'The previous conversation has been automatically compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
+      '',
+      '<compact_summary>',
+      result.summary,
+      '</compact_summary>',
+    ].join('\n'))
+    session.contextCompaction = {
+      summaryMessage,
+      compactedUpToIndex: tailStart,
+      compactedAt: new Date().toISOString(),
+      keepRecentTurns: settings.keepRecentTurns,
+      sourceMessageCount: messages.length,
+      usageBefore: usage,
+      thresholdPercent: settings.thresholdPercent,
+    }
+    session.lastAutoCompactAt = now
+    await persistSession(session)
+    emitSessionEvent(session, {
+      type: 'auto_compact_completed',
+      usage,
+      thresholdPercent: settings.thresholdPercent,
+      contextCompaction: session.contextCompaction,
+    })
+    emitSessionEvent(session, {
+      type: 'messages_replaced',
+      reason: 'auto_compact',
+      messages,
+      contextCompaction: session.contextCompaction,
+    })
+    return { compacted: true, usage }
+  } catch (error) {
+    logger?.warn?.(`Auto compact failed for session ${session.sessionId}:`, error?.message || error, { sessionId: session.sessionId })
+    return { compacted: false, usage, reason: 'error', error }
+  } finally {
+    session.autoCompacting = false
+  }
+}

package/server/routes/agent.mjs

@@ -20,6 +20,9 @@ import {
   updateSessionThinkingLevel,
   approveToolCall,
   rejectToolCall,
+  approveAutoCompact,
+  rejectAutoCompact,
+  abortToolCall,
   replaceSessionMessages,
   rollbackSessionMessages,
   agentEvents,
@@ -225,6 +228,30 @@ export async function handleAgentApi(req, res, url) {
     return
   }
 
+  // POST /api/agents/:sessionId/approve-auto-compact — approve a pending automatic context compaction
+  if (req.method === 'POST' && subPath === 'approve-auto-compact') {
+    const body = await readJsonBody(req)
+    const result = approveAutoCompact(sessionId, body?.approvalId)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/reject-auto-compact — skip a pending automatic context compaction
+  if (req.method === 'POST' && subPath === 'reject-auto-compact') {
+    const body = await readJsonBody(req)
+    const result = rejectAutoCompact(sessionId, body?.approvalId)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/abort-tool — abort a running run_command tool call
+  if (req.method === 'POST' && subPath === 'abort-tool') {
+    const body = await readJsonBody(req)
+    const result = abortToolCall(sessionId, body?.toolCallId)
+    sendJson(res, 200, result)
+    return
+  }
+
   const error = new Error('Not found')
   error.statusCode = 404
   throw error

package/server/tools/definitions.mjs

@@ -68,7 +68,7 @@ export const workspaceTools = [
     description: 'Run a shell command in the project bound to this chat. Use this for lint, build, tests, git status, and diagnostics.',
     parameters: Type.Object({
       command: Type.String({ description: 'Command to execute in the workspace.' }),
-      timeoutSeconds: Type.Optional(Type.Number({ description: 'Timeout in seconds. Defaults to 60.', default: 60 })),
+      timeoutSeconds: Type.Optional(Type.Number({ description: 'Timeout in seconds. Defaults to 600 (10 minutes).', default: 600 })),
     }),
     executionMode: 'sequential',
   },