@swarmclawai/swarmclaw 1.5.40 → 1.5.41

package/README.md

@@ -389,6 +389,10 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.5.41 Highlights
+
+- **Moonshot / Kimi compatibility — duplicate `files` tool name fixed**: any agent with the default `files` extension was sending two tools both literally named `files` to the LLM. Most providers tolerated the duplicate; Moonshot's strict tool-schema validation rejected it with `MoonshotException - function name files is duplicated` ([#39](https://github.com/swarmclawai/swarmclaw/issues/39), reported by [@SteamedFish](https://github.com/SteamedFish)). Three fixes: the v2 file builder is now correctly gated on `files_v2` (not `files`), it registers under the matching capability key, and the session-tools assembler now shares a single dedup Set across native, CRUD, and extension phases so any future name collision is rejected with a clear warning instead of a silent double-register.
+
 ### v1.5.40 Highlights
 
 - **Current-thread recall routing**: the message classifier now emits four explicit flags (`isCurrentThreadRecall`, `isGreeting`, `isAcknowledgement`, `isMemoryWriteIntent`) so the chat router stops treating in-thread pronouns ("your last reply", "both answers", "what I just said") as durable-memory queries. Previously small OSS models (`devstral-small-2:24b` and similar) would run `memory_search` for these, come back empty, and truthfully report "no memories found" even when the answer was three messages up.
@@ -426,12 +430,6 @@ Operational docs: https://swarmclaw.ai/docs/observability
   - Pins `outputFileTracingRoot` in `next.config.ts` to the project root so the Next.js build no longer walks `C:\Users\<user>\Application Data` (a legacy NTFS junction that throws EPERM on Windows runners).
   - Pins Python 3.11 in the desktop-release workflow so `node-gyp` rebuilds of native modules (`node-liblzma`, etc.) succeed on Python 3.12+ runners where `distutils` was removed from the stdlib.
 
-### v1.5.36 Highlights
-
-- **Desktop app (Electron)**: SwarmClaw now ships as a native desktop app for macOS (Apple Silicon + Intel), Windows, and Linux (AppImage + .deb). Download from [swarmclaw.ai/downloads](https://swarmclaw.ai/downloads). The app wraps the existing standalone server inside an Electron shell, stores data in the OS app-data directory, and auto-updates via GitHub Releases (notify-only on unsigned macOS builds).
-- **Desktop release CI**: new `desktop-release.yml` workflow builds and publishes installers for all three platforms to GitHub Releases on every version tag.
-- **UI cleanup**: removed sibling-product navigation links from the in-app sidebar rail and login gate so the open-source app focuses on SwarmClaw itself. Those links remain in the project README and on swarmclaw.ai.
-
 Older releases: https://swarmclaw.ai/docs/release-notes
 
 - GitHub releases: https://github.com/swarmclawai/swarmclaw/releases

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.5.40",
+  "version": "1.5.41",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",

package/src/lib/server/session-tools/build-session-tools-dedup.test.ts

@@ -0,0 +1,127 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+// Issue #39 (Moonshot/Kimi rejecting duplicate tool names) showed that the
+// Phase 1 native-tool loop in `session-tools/index.ts` was pushing tools
+// without checking for duplicate names. Phase 2 already had a dedup Set; the
+// fix lifts that Set above Phase 1 so all phases share it.
+//
+// This test mirrors the dedup algorithm in pure form so it can be verified
+// without booting the full session-tools graph (which OOMs in test workers
+// when run alongside the dev server).
+
+type FakeTool = { name: string }
+type Builder = () => FakeTool[]
+
+interface DedupWarn {
+  toolName: string
+  source: 'native' | 'crud' | 'extension'
+  extensionId?: string
+}
+
+function dedupAssemble(
+  nativeBuilders: ReadonlyArray<readonly [string, Builder]>,
+  crudBuilder: Builder,
+  extensionTools: ReadonlyArray<{ extensionId: string; tool: FakeTool }>,
+): { tools: FakeTool[]; warnings: DedupWarn[] } {
+  const tools: FakeTool[] = []
+  const warnings: DedupWarn[] = []
+  const existingNames = new Set<string>()
+
+  for (const [extensionId, builder] of nativeBuilders) {
+    for (const t of builder()) {
+      if (existingNames.has(t.name)) {
+        warnings.push({ toolName: t.name, source: 'native', extensionId })
+        continue
+      }
+      existingNames.add(t.name)
+      tools.push(t)
+    }
+  }
+
+  for (const t of crudBuilder()) {
+    if (existingNames.has(t.name)) {
+      warnings.push({ toolName: t.name, source: 'crud' })
+      continue
+    }
+    existingNames.add(t.name)
+    tools.push(t)
+  }
+
+  for (const entry of extensionTools) {
+    if (existingNames.has(entry.tool.name)) {
+      warnings.push({ toolName: entry.tool.name, source: 'extension', extensionId: entry.extensionId })
+      continue
+    }
+    existingNames.add(entry.tool.name)
+    tools.push(entry.tool)
+  }
+
+  return { tools, warnings }
+}
+
+describe('session-tools assembler dedup (issue #39 regression)', () => {
+  it('emits a single `files` tool when two native builders both produce one (the original issue #39 scenario)', () => {
+    const result = dedupAssemble(
+      [
+        ['files', () => [{ name: 'files' }]],
+        ['files_v2', () => [{ name: 'files' }]],
+      ],
+      () => [],
+      [],
+    )
+
+    const fileTools = result.tools.filter((t) => t.name === 'files')
+    assert.equal(fileTools.length, 1, 'must emit exactly one tool named "files"')
+    assert.equal(result.warnings.length, 1)
+    assert.equal(result.warnings[0].toolName, 'files')
+    assert.equal(result.warnings[0].source, 'native')
+    assert.equal(result.warnings[0].extensionId, 'files_v2')
+  })
+
+  it('first builder wins when names collide', () => {
+    const t1 = { name: 'shared' }
+    const t2 = { name: 'shared' }
+    const result = dedupAssemble(
+      [
+        ['ext-a', () => [t1]],
+        ['ext-b', () => [t2]],
+      ],
+      () => [],
+      [],
+    )
+    assert.equal(result.tools.length, 1)
+    assert.strictEqual(result.tools[0], t1)
+  })
+
+  it('CRUD tools cannot collide with native tools', () => {
+    const result = dedupAssemble(
+      [['ext-a', () => [{ name: 'crud_op' }]]],
+      () => [{ name: 'crud_op' }],
+      [],
+    )
+    assert.equal(result.tools.length, 1)
+    assert.equal(result.warnings[0].source, 'crud')
+  })
+
+  it('extension tools dedup against the same shared Set', () => {
+    const result = dedupAssemble(
+      [['ext-a', () => [{ name: 'foo' }]]],
+      () => [],
+      [{ extensionId: 'ext-b', tool: { name: 'foo' } }],
+    )
+    assert.equal(result.tools.length, 1)
+    assert.equal(result.warnings[0].source, 'extension')
+    assert.equal(result.warnings[0].extensionId, 'ext-b')
+  })
+
+  it('lets distinct names through unchanged', () => {
+    const result = dedupAssemble(
+      [['ext-a', () => [{ name: 'a' }, { name: 'b' }]]],
+      () => [{ name: 'c' }],
+      [{ extensionId: 'ext-b', tool: { name: 'd' } }],
+    )
+    assert.deepEqual(result.tools.map((t) => t.name), ['a', 'b', 'c', 'd'])
+    assert.equal(result.warnings.length, 0)
+  })
+})

package/src/lib/server/session-tools/files-tool.test.ts

@@ -0,0 +1,56 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { buildFilesTools } from '@/lib/server/session-tools/files-tool'
+import type { ToolBuildContext } from '@/lib/server/session-tools/context'
+
+function makeBctx(enabled: Set<string>): ToolBuildContext {
+  return {
+    cwd: '/tmp',
+    ctx: undefined,
+    hasExtension: (name) => enabled.has(name),
+    hasTool: (name) => enabled.has(name),
+    cleanupFns: [],
+    commandTimeoutMs: 0,
+    claudeTimeoutMs: 0,
+    cliProcessTimeoutMs: 0,
+    persistDelegateResumeId: () => {},
+    readStoredDelegateResumeId: () => null,
+    resolveCurrentSession: () => null,
+    activeExtensions: Array.from(enabled),
+    filesystemScope: 'workspace',
+  }
+}
+
+describe('buildFilesTools (issue #39)', () => {
+  it('returns no tools when only the legacy `files` extension is enabled', () => {
+    // Pre-fix this returned a tool named "files", on top of the v1 builder
+    // which already produced a tool with the same name. Moonshot/Kimi rejected
+    // the duplicate with `function name files is duplicated`.
+    const bctx = makeBctx(new Set(['files']))
+    const out = buildFilesTools(bctx)
+    assert.equal(out.length, 0)
+  })
+
+  it('returns no tools when no relevant extension is enabled', () => {
+    const bctx = makeBctx(new Set(['shell', 'web']))
+    const out = buildFilesTools(bctx)
+    assert.equal(out.length, 0)
+  })
+
+  it('returns one `files` tool when the v2 extension is explicitly enabled', () => {
+    const bctx = makeBctx(new Set(['files_v2']))
+    const out = buildFilesTools(bctx)
+    assert.equal(out.length, 1)
+    assert.equal(out[0].name, 'files')
+  })
+
+  it('returns one `files` tool when both `files` and `files_v2` are enabled', () => {
+    // Defensive: even with both enabled, this builder emits exactly one tool.
+    // (The duplicate-with-v1 protection lives in the session-tools assembler
+    // dedup loop, covered by build-session-tools-dedup.test.ts.)
+    const bctx = makeBctx(new Set(['files', 'files_v2']))
+    const out = buildFilesTools(bctx)
+    assert.equal(out.length, 1)
+    assert.equal(out[0].name, 'files')
+  })
+})

package/src/lib/server/session-tools/files-tool.ts

@@ -608,14 +608,22 @@ const FilesExtension: Extension = {
   ],
 }
 
-registerNativeCapability('files', FilesExtension)
+// Registered under 'files_v2' to avoid colliding with the v1 FileExtension
+// in `file.ts`, which also registers under the literal key 'files'. The
+// builder below is wired into `session-tools/index.ts` via the same key.
+registerNativeCapability('files_v2', FilesExtension)
 
 // ---------------------------------------------------------------------------
 // Tool builder (called from session-tools/index.ts)
 // ---------------------------------------------------------------------------
 
 export function buildFilesTools(bctx: ToolBuildContext) {
-  if (!bctx.hasExtension('files')) return []
+  // Gate on 'files_v2' (not 'files'). Previously this checked 'files', which
+  // meant that enabling the v1 `files` extension activated BOTH builders and
+  // registered two tools literally named "files". Most providers tolerate
+  // duplicate tool names; Moonshot/Kimi rejects them with `function name
+  // files is duplicated`. Reported as issue #39.
+  if (!bctx.hasExtension('files_v2')) return []
 
   return [
     tool(

package/src/lib/server/session-tools/index.ts

@@ -221,24 +221,41 @@ export async function buildSessionTools(cwd: string, enabledExtensions: string[]
       ['swarmdock', buildSwarmDockTools],
     ]
 
+    // Track tool names across all phases so duplicates are rejected
+    // consistently. Issue #39: Moonshot rejects duplicate tool names that
+    // most providers silently tolerate, so guarding only Phase 2 (as the
+    // pre-fix code did) was not enough.
+    const existingNames = new Set<string>()
     for (const [extensionId, builder] of nativeBuilders) {
       const builtTools = builder(bctx)
       for (const t of builtTools) {
+        if (existingNames.has(t.name)) {
+          log.warn('session-tools', 'Skipping native tool due to duplicate name', {
+            toolName: t.name,
+            extensionId,
+          })
+          continue
+        }
+        existingNames.add(t.name)
         toolToExtensionMap[t.name] = extensionId
+        tools.push(t)
       }
-      tools.push(...builtTools)
     }
 
     const crudTools = buildCrudTools(bctx)
     for (const toolEntry of crudTools) {
+      if (existingNames.has(toolEntry.name)) {
+        log.warn('session-tools', 'Skipping CRUD tool due to duplicate name', { toolName: toolEntry.name })
+        continue
+      }
+      existingNames.add(toolEntry.name)
       toolToExtensionMap[toolEntry.name] = toolEntry.name
+      tools.push(toolEntry)
     }
-    tools.push(...crudTools)
 
     // 2. Build Extension Tools (Built-in + External)
     try {
       const extensionTools = extensionManager.getTools(activeExtensions)
-      const existingNames = new Set(tools.map((t) => t.name))
       
       for (const entry of extensionTools) {
         const pt = entry.tool