@swarmclawai/swarmclaw 1.9.1 → 1.9.3

package/src/lib/server/agents/delegation-advisory.test.ts

@@ -124,6 +124,7 @@ describe('delegation-advisory', () => {
     assert.equal(result.shouldDelegate, true)
     assert.equal(result.style, 'managerial')
     assert.equal(result.recommended?.agentId, 'builder')
+    assert.equal(result.recommended?.routeKey, 'coding:coding,debugging,implementation:builder')
     assert.match(advisory.formatDelegationRationale(result.recommended), /coding/i)
   })
 

package/src/lib/server/agents/delegation-advisory.ts

@@ -20,6 +20,7 @@ export interface DelegationTaskProfile {
 export interface DelegationCandidateFit {
   agentId: string
   agentName: string
+  routeKey: string
   score: number
   availability: 'idle' | 'working' | 'unknown'
   matchedCapabilities: string[]
@@ -76,6 +77,14 @@ function matchedCapabilities(agentCapabilities: string[] | undefined, requiredCa
   return requiredCapabilities.filter((entry) => agentSet.has(entry.toLowerCase()))
 }
 
+function buildRouteKey(agent: Agent, profile: DelegationTaskProfile): string {
+  const required = profile.requiredCapabilities
+    .map((entry) => entry.toLowerCase())
+    .sort()
+    .join(',')
+  return [profile.workType, required || 'general', agent.id].join(':')
+}
+
 function roleAdjustment(agent: Agent, profile: DelegationTaskProfile): number {
   const role = agent.role === 'coordinator' ? 'coordinator' : 'worker'
   if (profile.workType === 'operations') {
@@ -141,6 +150,7 @@ function buildCandidateFit(
   return {
     agentId: agent.id,
     agentName: agent.name,
+    routeKey: buildRouteKey(agent, profile),
     score,
     availability,
     matchedCapabilities: matched,

package/src/lib/server/chat-execution/iteration-event-handler.ts

@@ -30,6 +30,7 @@ import {
   createReasoningContentMetadata,
   extractReasoningContentDelta,
 } from '@/lib/providers/deepseek-reasoning-chat-openai'
+import { StreamingReasoningTagScrubber } from '@/lib/server/chat-execution/reasoning-tag-scrubber'
 
 // ---------------------------------------------------------------------------
 // LangGraph event kind constants
@@ -92,10 +93,24 @@ export async function processIterationEvents(opts: ProcessIterationEventsOpts):
   let toolEndCount = 0
   const iterationText = { value: '' }
   const toolPerfEnds = new Map<string, (extra?: Record<string, unknown>) => number>()
+  const reasoningTagScrubber = new StreamingReasoningTagScrubber()
 
   /** Interval for progress checkpoint nudges */
   const PROGRESS_CHECK_INTERVAL = 10
 
+  const emitThinking = (text: string) => {
+    if (!text) return
+    state.accumulatedThinking += text
+    write(`data: ${JSON.stringify({ t: 'thinking', text })}\n\n`)
+  }
+
+  const appendScrubbedText = (text: string) => {
+    if (!text) return
+    const scrubbed = reasoningTagScrubber.feed(text)
+    if (scrubbed.reasoning) emitThinking(scrubbed.reasoning)
+    if (scrubbed.visible) state.appendText(scrubbed.visible, iterationText, write)
+  }
+
   for await (const event of eventStream) {
     const kind = event.event
 
@@ -104,27 +119,24 @@ export async function processIterationEvents(opts: ProcessIterationEventsOpts):
       const chunk = event.data?.chunk
       const reasoningDelta = extractReasoningContentDelta(chunk?.additional_kwargs as Record<string, unknown> | undefined)
       if (reasoningDelta) {
-        state.accumulatedThinking += reasoningDelta
-        write(`data: ${JSON.stringify({ t: 'thinking', text: reasoningDelta })}\n\n`)
+        emitThinking(reasoningDelta)
         write(`data: ${JSON.stringify({ t: 'md', text: JSON.stringify(createReasoningContentMetadata(reasoningDelta)) })}\n\n`)
       }
       if (chunk?.content) {
         if (Array.isArray(chunk.content)) {
           for (const block of chunk.content) {
             if (block.type === 'thinking' && block.thinking) {
-              state.accumulatedThinking += block.thinking
-              write(`data: ${JSON.stringify({ t: 'thinking', text: block.thinking })}\n\n`)
+              emitThinking(block.thinking)
             } else if (typeof block.text === 'string' && block.text.startsWith('[[thinking]]')) {
-              state.accumulatedThinking += block.text.slice(12)
-              write(`data: ${JSON.stringify({ t: 'thinking', text: block.text.slice(12) })}\n\n`)
+              emitThinking(block.text.slice(12))
             } else if (block.text) {
-              state.appendText(block.text, iterationText, write)
+              appendScrubbedText(block.text)
             }
           }
         } else {
           const text = typeof chunk.content === 'string' ? chunk.content : ''
           if (text) {
-            state.appendText(text, iterationText, write)
+            appendScrubbedText(text)
           }
         }
       }
@@ -351,6 +363,10 @@ export async function processIterationEvents(opts: ProcessIterationEventsOpts):
     }
   }
 
+  const finalScrubbed = reasoningTagScrubber.flush()
+  if (finalScrubbed.reasoning) emitThinking(finalScrubbed.reasoning)
+  if (finalScrubbed.visible) state.appendText(finalScrubbed.visible, iterationText, write)
+
   return {
     reachedExecutionBoundary,
     executionFollowthroughReason,

package/src/lib/server/chat-execution/reasoning-tag-scrubber.test.ts

@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { StreamingReasoningTagScrubber } from './reasoning-tag-scrubber'
+import { ChatTurnState } from './chat-turn-state'
+import { processIterationEvents } from './iteration-event-handler'
+
+function drive(deltas: string[]) {
+  const scrubber = new StreamingReasoningTagScrubber()
+  let visible = ''
+  let reasoning = ''
+  for (const delta of deltas) {
+    const result = scrubber.feed(delta)
+    visible += result.visible
+    reasoning += result.reasoning
+  }
+  const final = scrubber.flush()
+  visible += final.visible
+  reasoning += final.reasoning
+  return { visible, reasoning }
+}
+
+test('strips closed reasoning pairs from visible text and captures reasoning', () => {
+  assert.deepEqual(
+    drive(['Hello <think>private note</think> world']),
+    { visible: 'Hello  world', reasoning: 'private note' },
+  )
+})
+
+test('handles all supported tag variants case-insensitively', () => {
+  assert.deepEqual(
+    drive(['<THINKING>a</Thinking><reasoning>b</reasoning><thought>c</thought><REASONING_SCRATCHPAD>d</REASONING_SCRATCHPAD>done']),
+    { visible: 'done', reasoning: 'abcd' },
+  )
+})
+
+test('holds split opening tags across stream deltas', () => {
+  assert.deepEqual(
+    drive(['<', 'think>reasoning</think>', 'done']),
+    { visible: 'done', reasoning: 'reasoning' },
+  )
+})
+
+test('captures reasoning until a split close tag resolves', () => {
+  assert.deepEqual(
+    drive(['<think>first', ' second</th', 'ink>answer']),
+    { visible: 'answer', reasoning: 'first second' },
+  )
+})
+
+test('does not treat a mid-line prose mention as an open reasoning block', () => {
+  const text = 'Use the <think> element for examples'
+  assert.deepEqual(drive([text]), { visible: text, reasoning: '' })
+})
+
+test('does strip a bounded mid-line pair because it is model reasoning markup', () => {
+  assert.deepEqual(
+    drive(['Use <think>hidden</think>this answer']),
+    { visible: 'Use this answer', reasoning: 'hidden' },
+  )
+})
+
+test('drops unterminated reasoning content at flush after capturing streamed content', () => {
+  assert.deepEqual(
+    drive(['Visible\n<think>private reasoning with no close']),
+    { visible: 'Visible\n', reasoning: 'private reasoning with no close' },
+  )
+})
+
+test('reset clears an interrupted reasoning block and buffered partial tags', () => {
+  const scrubber = new StreamingReasoningTagScrubber()
+  assert.deepEqual(scrubber.feed('<think>hanging'), { visible: '', reasoning: 'hanging' })
+  scrubber.reset()
+  assert.deepEqual(scrubber.feed('fresh<'), { visible: 'fresh', reasoning: '' })
+  scrubber.reset()
+  assert.deepEqual(scrubber.feed('content'), { visible: 'content', reasoning: '' })
+})
+
+test('processIterationEvents routes split reasoning tags away from visible deltas', async () => {
+  async function* eventStream() {
+    yield { event: 'on_chat_model_stream', data: { chunk: { content: '<' } } }
+    yield { event: 'on_chat_model_stream', data: { chunk: { content: 'think>private' } } }
+    yield { event: 'on_chat_model_stream', data: { chunk: { content: ' reasoning</th' } } }
+    yield { event: 'on_chat_model_stream', data: { chunk: { content: 'ink>done' } } }
+  }
+
+  const state = new ChatTurnState()
+  const writes: string[] = []
+  const outcome = await processIterationEvents({
+    eventStream: eventStream(),
+    state,
+    timers: {
+      armIdleWatchdog: () => undefined,
+      clearIdleWatchdog: () => undefined,
+      clearRequiredToolKickoff: () => undefined,
+    } as never,
+    loopTracker: {} as never,
+    toolEventTracker: {} as never,
+    session: { id: 'sess_reasoning_tags', provider: 'openai', model: 'gpt-4o-mini' } as never,
+    message: 'answer briefly',
+    write: (data: string) => writes.push(data),
+    sessionExtensions: [],
+    boundedExternalExecutionTask: false,
+    toolToExtensionMap: {},
+    iterationController: new AbortController(),
+  })
+
+  assert.equal(outcome.iterationText, 'done')
+  assert.equal(state.fullText, 'done')
+  assert.equal(state.accumulatedThinking, 'private reasoning')
+
+  const rendered = writes.join('')
+  assert.match(rendered, /"t":"thinking"/)
+  assert.match(rendered, /"text":"private"/)
+  assert.match(rendered, /"text":" reasoning"/)
+  assert.doesNotMatch(rendered, /"t":"d"[^\n]*private/)
+  assert.doesNotMatch(rendered, /<think>|<\/think>/i)
+})

package/src/lib/server/chat-execution/reasoning-tag-scrubber.ts

@@ -0,0 +1,219 @@
+export interface ReasoningTagScrubResult {
+  visible: string
+  reasoning: string
+}
+
+const TAG_NAMES = [
+  'think',
+  'thinking',
+  'reasoning',
+  'thought',
+  'reasoning_scratchpad',
+] as const
+
+const OPEN_TAGS = TAG_NAMES.map((name) => `<${name}>`)
+const CLOSE_TAGS = TAG_NAMES.map((name) => `</${name}>`)
+const MAX_TAG_LENGTH = Math.max(...OPEN_TAGS.map((tag) => tag.length), ...CLOSE_TAGS.map((tag) => tag.length))
+
+function isWhitespace(text: string): boolean {
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i)
+    if (code !== 9 && code !== 10 && code !== 11 && code !== 12 && code !== 13 && code !== 32) return false
+  }
+  return true
+}
+
+function matchTagAt(lowerText: string, index: number, tags: string[]): number {
+  for (const tag of tags) {
+    if (lowerText.startsWith(tag, index)) return tag.length
+  }
+  return 0
+}
+
+function findFirstTag(text: string, tags: string[]): { index: number; length: number } {
+  const lowerText = text.toLowerCase()
+  let bestIndex = -1
+  let bestLength = 0
+  for (const tag of tags) {
+    const index = lowerText.indexOf(tag)
+    if (index !== -1 && (bestIndex === -1 || index < bestIndex)) {
+      bestIndex = index
+      bestLength = tag.length
+    }
+  }
+  return { index: bestIndex, length: bestLength }
+}
+
+function maxPartialSuffix(text: string, tags: string[]): number {
+  const lowerText = text.toLowerCase()
+  const maxLength = Math.min(MAX_TAG_LENGTH - 1, lowerText.length)
+  let best = 0
+  for (let length = 1; length <= maxLength; length++) {
+    const suffix = lowerText.slice(-length)
+    if (tags.some((tag) => tag.startsWith(suffix))) best = length
+  }
+  return best
+}
+
+function stripOrphanCloseTags(text: string): string {
+  const lowerText = text.toLowerCase()
+  let output = ''
+  let index = 0
+  while (index < text.length) {
+    const closeLength = matchTagAt(lowerText, index, CLOSE_TAGS)
+    if (closeLength > 0) {
+      index += closeLength
+      while (index < text.length && isWhitespace(text[index])) index++
+      continue
+    }
+    output += text[index]
+    index++
+  }
+  return output
+}
+
+export class StreamingReasoningTagScrubber {
+  private inBlock = false
+  private buffer = ''
+  private lastVisibleEndedNewline = true
+
+  reset(): void {
+    this.inBlock = false
+    this.buffer = ''
+    this.lastVisibleEndedNewline = true
+  }
+
+  feed(text: string): ReasoningTagScrubResult {
+    if (!text) return { visible: '', reasoning: '' }
+    let buffer = this.buffer + text
+    this.buffer = ''
+    let visible = ''
+    let reasoning = ''
+
+    while (buffer) {
+      if (this.inBlock) {
+        const close = findFirstTag(buffer, CLOSE_TAGS)
+        if (close.index === -1) {
+          const held = maxPartialSuffix(buffer, CLOSE_TAGS)
+          const captureEnd = held ? buffer.length - held : buffer.length
+          reasoning += buffer.slice(0, captureEnd)
+          this.buffer = held ? buffer.slice(-held) : ''
+          return { visible, reasoning }
+        }
+        reasoning += buffer.slice(0, close.index)
+        buffer = buffer.slice(close.index + close.length)
+        this.inBlock = false
+        continue
+      }
+
+      const pair = this.findEarliestClosedPair(buffer)
+      const open = this.findOpenAtBoundary(buffer)
+
+      if (pair && (open.index === -1 || pair.start <= open.index)) {
+        const preceding = stripOrphanCloseTags(buffer.slice(0, pair.start))
+        if (preceding) {
+          visible += preceding
+          this.lastVisibleEndedNewline = preceding.endsWith('\n')
+        }
+        reasoning += buffer.slice(pair.contentStart, pair.contentEnd)
+        buffer = buffer.slice(pair.end)
+        continue
+      }
+
+      if (open.index !== -1) {
+        const preceding = stripOrphanCloseTags(buffer.slice(0, open.index))
+        if (preceding) {
+          visible += preceding
+          this.lastVisibleEndedNewline = preceding.endsWith('\n')
+        }
+        this.inBlock = true
+        buffer = buffer.slice(open.index + open.length)
+        continue
+      }
+
+      const held = Math.max(maxPartialSuffix(buffer, OPEN_TAGS), maxPartialSuffix(buffer, CLOSE_TAGS))
+      const emitText = held ? buffer.slice(0, -held) : buffer
+      this.buffer = held ? buffer.slice(-held) : ''
+      if (emitText) {
+        const cleaned = stripOrphanCloseTags(emitText)
+        if (cleaned) {
+          visible += cleaned
+          this.lastVisibleEndedNewline = cleaned.endsWith('\n')
+        }
+      }
+      return { visible, reasoning }
+    }
+
+    return { visible, reasoning }
+  }
+
+  flush(): ReasoningTagScrubResult {
+    if (this.inBlock) {
+      this.inBlock = false
+      this.buffer = ''
+      return { visible: '', reasoning: '' }
+    }
+    const tail = stripOrphanCloseTags(this.buffer)
+    this.buffer = ''
+    if (tail) this.lastVisibleEndedNewline = tail.endsWith('\n')
+    return { visible: tail, reasoning: '' }
+  }
+
+  private findEarliestClosedPair(text: string): {
+    start: number
+    contentStart: number
+    contentEnd: number
+    end: number
+  } | null {
+    const lowerText = text.toLowerCase()
+    let best: { start: number; contentStart: number; contentEnd: number; end: number } | null = null
+    for (const name of TAG_NAMES) {
+      const openTag = `<${name}>`
+      const closeTag = `</${name}>`
+      let searchFrom = 0
+      while (searchFrom < lowerText.length) {
+        const start = lowerText.indexOf(openTag, searchFrom)
+        if (start === -1) break
+        const contentStart = start + openTag.length
+        const contentEnd = lowerText.indexOf(closeTag, contentStart)
+        if (contentEnd !== -1) {
+          const candidate = {
+            start,
+            contentStart,
+            contentEnd,
+            end: contentEnd + closeTag.length,
+          }
+          if (!best || candidate.start < best.start) best = candidate
+          break
+        }
+        searchFrom = contentStart
+      }
+    }
+    return best
+  }
+
+  private findOpenAtBoundary(text: string): { index: number; length: number } {
+    const lowerText = text.toLowerCase()
+    let best = { index: -1, length: 0 }
+    for (const openTag of OPEN_TAGS) {
+      let searchFrom = 0
+      while (searchFrom < lowerText.length) {
+        const index = lowerText.indexOf(openTag, searchFrom)
+        if (index === -1) break
+        if (this.isBlockBoundary(text.slice(0, index))) {
+          if (best.index === -1 || index < best.index) best = { index, length: openTag.length }
+          break
+        }
+        searchFrom = index + openTag.length
+      }
+    }
+    return best
+  }
+
+  private isBlockBoundary(preceding: string): boolean {
+    if (!preceding) return this.lastVisibleEndedNewline
+    const lastNewline = Math.max(preceding.lastIndexOf('\n'), preceding.lastIndexOf('\r'))
+    if (lastNewline !== -1) return isWhitespace(preceding.slice(lastNewline + 1))
+    return this.lastVisibleEndedNewline && isWhitespace(preceding)
+  }
+}

package/src/lib/server/extension-managed-resources.test.ts

@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict'
+import test, { afterEach } from 'node:test'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+import { getExtensionManager } from './extensions'
+import {
+  inspectExtensionLocalFolder,
+  listExtensionLocalFolderEntries,
+  listExtensionManagedResources,
+  reconcileExtensionManagedResources,
+  setExtensionLocalFolderConfig,
+} from './extension-managed-resources'
+import { loadAgents, loadSchedules, loadSettings, saveAgents, saveSchedules, saveSettings } from './storage'
+
+const originalAgents = loadAgents()
+const originalSchedules = loadSchedules()
+const originalSettings = loadSettings()
+
+let seq = 0
+
+function extensionId(prefix: string): string {
+  seq += 1
+  return `${prefix}_${Date.now()}_${seq}`
+}
+
+afterEach(() => {
+  saveAgents(originalAgents)
+  saveSchedules(originalSchedules)
+  saveSettings(originalSettings)
+})
+
+test('managed resources summary and reconcile create extension-owned agents and schedules', () => {
+  const id = extensionId('managed_resources')
+  getExtensionManager().registerBuiltin(id, {
+    name: 'Managed Resource Fixture',
+    description: 'Declares resources for tests.',
+    managedResources: {
+      agents: [
+        {
+          agentKey: 'researcher',
+          displayName: 'Managed Researcher',
+          description: 'Research managed by an extension.',
+          systemPrompt: 'Research carefully.',
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          capabilities: ['research'],
+          extensions: ['web'],
+        },
+      ],
+      routines: [
+        {
+          routineKey: 'daily-digest',
+          title: 'Daily Digest',
+          assigneeRef: { resourceKind: 'agent', resourceKey: 'researcher' },
+          taskPrompt: 'Prepare a digest.',
+          triggers: [{ kind: 'schedule', cronExpression: '0 9 * * *', timezone: 'UTC' }],
+        },
+      ],
+      gatewayPlatforms: [
+        {
+          platformKey: 'openai-api',
+          displayName: 'OpenAI-compatible API',
+          transport: 'http',
+          endpoint: 'http://127.0.0.1:8642/v1',
+        },
+      ],
+      setupChecks: [
+        { checkKey: 'api-key', displayName: 'API key configured', kind: 'env', target: 'OPENAI_API_KEY' },
+      ],
+    },
+  })
+
+  const before = listExtensionManagedResources().extensions.find((entry) => entry.extensionId === id)
+  assert.ok(before)
+  assert.equal(before.agents[0].status, 'missing')
+  assert.equal(before.schedules[0].status, 'missing_ref')
+
+  const result = reconcileExtensionManagedResources(id)
+  assert.equal(result.createdAgents.length, 1)
+  assert.equal(result.createdSchedules.length, 1)
+  assert.deepEqual(result.skipped, [])
+
+  const agents = loadAgents()
+  const agent = agents[result.createdAgents[0]]
+  assert.equal(agent.name, 'Managed Researcher')
+  assert.equal(agent.managedByExtension?.extensionId, id)
+  assert.equal(agent.managedByExtension?.resourceKey, 'researcher')
+  assert.ok(agent.extensions?.includes(id))
+  assert.ok(agent.extensions?.includes('web'))
+
+  const schedules = loadSchedules()
+  const schedule = schedules[result.createdSchedules[0]]
+  assert.equal(schedule.name, 'Daily Digest')
+  assert.equal(schedule.agentId, agent.id)
+  assert.equal(schedule.scheduleType, 'cron')
+  assert.equal(schedule.cron, '0 9 * * *')
+  assert.equal(schedule.status, 'paused')
+  assert.equal(schedule.managedByExtension?.resourceKey, 'daily-digest')
+
+  const after = listExtensionManagedResources().extensions.find((entry) => entry.extensionId === id)
+  assert.equal(after?.agents[0].status, 'resolved')
+  assert.equal(after?.schedules[0].status, 'resolved')
+  assert.equal(after?.gatewayPlatforms.length, 1)
+  assert.equal(after?.setupChecks.length, 1)
+})
+
+test('local folder inspection and listing stay inside configured roots', async () => {
+  const id = extensionId('managed_folder')
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-managed-folder-'))
+  fs.mkdirSync(path.join(tempDir, 'inputs'))
+  fs.mkdirSync(path.join(tempDir, 'outputs'))
+  fs.writeFileSync(path.join(tempDir, 'inputs', 'brief.txt'), 'hello\n')
+
+  getExtensionManager().registerBuiltin(id, {
+    name: 'Managed Folder Fixture',
+    managedResources: {
+      localFolders: [
+        {
+          folderKey: 'workspace',
+          displayName: 'Workspace Folder',
+          access: 'readWrite',
+          requiredDirectories: ['inputs', 'outputs'],
+          requiredFiles: ['inputs/brief.txt'],
+        },
+      ],
+    },
+  })
+
+  setExtensionLocalFolderConfig({
+    extensionId: id,
+    folderKey: 'workspace',
+    path: tempDir,
+  })
+
+  const status = await inspectExtensionLocalFolder({ extensionId: id, folderKey: 'workspace' })
+  assert.equal(status.healthy, true)
+  assert.equal(status.readable, true)
+  assert.equal(status.writable, true)
+
+  const listing = await listExtensionLocalFolderEntries({
+    extensionId: id,
+    folderKey: 'workspace',
+    recursive: true,
+  })
+  assert.ok(listing.entries.some((entry) => entry.path === 'inputs/brief.txt' && entry.kind === 'file'))
+
+  await assert.rejects(
+    () => listExtensionLocalFolderEntries({
+      extensionId: id,
+      folderKey: 'workspace',
+      relativePath: '../outside',
+    }),
+    /inside the configured root|traversal/,
+  )
+
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})