@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/providers/ollama.ts

@@ -2,7 +2,7 @@ import fs from 'fs'
 import http from 'http'
 import https from 'https'
 import type { StreamChatOptions } from './index'
-import { PROVIDER_DEFAULTS } from './provider-defaults'
+import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
 
 const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
 const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
@@ -10,9 +10,19 @@ const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp
 export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
   return new Promise((resolve) => {
     const messages = buildMessages(session, message, imagePath, loadHistory)
-    const model = session.model || 'llama3'
-    // Cloud: no endpoint but API key present → use Ollama cloud
-    const endpoint = session.apiEndpoint || (apiKey ? PROVIDER_DEFAULTS.ollamaCloud : PROVIDER_DEFAULTS.ollama)
+    const runtime = resolveOllamaRuntimeConfig({
+      model: session.model,
+      apiKey,
+      apiEndpoint: session.apiEndpoint,
+    })
+    const model = runtime.model || 'llama3'
+    const endpoint = runtime.endpoint
+    if (runtime.useCloud && !runtime.apiKey) {
+      write(`data: ${JSON.stringify({ t: 'err', text: 'Ollama Cloud model requires an API key. Set OLLAMA_API_KEY or attach an Ollama credential.' })}\n\n`)
+      active.delete(session.id)
+      resolve('')
+      return
+    }
 
     const parsed = new URL(endpoint)
     const isHttps = parsed.protocol === 'https:'
@@ -43,8 +53,8 @@ export function streamOllamaChat({ session, message, imagePath, apiKey, write, a
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
     }
-    if (apiKey) {
-      headers['Authorization'] = `Bearer ${apiKey}`
+    if (runtime.apiKey) {
+      headers['Authorization'] = `Bearer ${runtime.apiKey}`
     }
 
     const apiReq = transport.request({

package/src/lib/providers/openclaw.test.ts

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict'
+import { afterEach, test } from 'node:test'
+
+import { resolveGatewayAgentId } from './openclaw'
+import { loadAgents, saveAgents } from '../server/storage'
+import type { Agent } from '@/types'
+
+const originalAgents = loadAgents({ includeTrashed: true })
+
+afterEach(() => {
+  saveAgents(originalAgents)
+})
+
+test('resolveGatewayAgentId prefers the matching OpenClaw agent name from storage', () => {
+  const agents = loadAgents({ includeTrashed: true })
+  agents['openclaw-agent-test'] = {
+    id: 'openclaw-agent-test',
+    name: 'Research Operator',
+    systemPrompt: '',
+    provider: 'openclaw',
+    model: 'default',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  } as Agent
+  saveAgents(agents)
+
+  const resolved = resolveGatewayAgentId({
+    id: 'session-1',
+    agentId: 'openclaw-agent-test',
+    shortcutForAgentId: 'openclaw-agent-test',
+    name: 'Some Other Name',
+  })
+
+  assert.equal(resolved, 'research-operator')
+})
+
+test('resolveGatewayAgentId honors explicit OpenClaw agent ids when provided', () => {
+  const resolved = resolveGatewayAgentId({
+    id: 'session-2',
+    openclawAgentId: 'Custom Gateway Agent',
+    name: 'Ignored',
+  })
+
+  assert.equal(resolved, 'custom-gateway-agent')
+})
+
+test('resolveGatewayAgentId falls back to the session name when no OpenClaw agent is available', () => {
+  const resolved = resolveGatewayAgentId({
+    id: 'session-3',
+    name: 'Fallback Agent Name',
+  })
+
+  assert.equal(resolved, 'fallback-agent-name')
+})

package/src/lib/providers/openclaw.ts

@@ -3,6 +3,14 @@ import crypto, { randomUUID } from 'crypto'
 import fs from 'fs'
 import path from 'path'
 import type { StreamChatOptions } from './index'
+import type { Agent } from '@/types'
+import { deriveOpenClawWsUrl } from '@/lib/openclaw-endpoint'
+import { normalizeOpenClawAgentId } from '@/lib/openclaw-agent-id'
+import { loadAgents } from '../server/storage'
+import {
+  resolveOpenClawGatewayAgentIdFromList,
+  type OpenClawGatewayAgentSummary,
+} from '../server/openclaw-agent-resolver'
 
 // --- Device Identity (Ed25519 keypair for gateway auth) ---
 
@@ -105,13 +113,6 @@ export function getDeviceId(): string {
 
 // --- Protocol helpers ---
 
-function normalizeWsUrl(raw: string): string {
-  let url = raw.replace(/\/+$/, '')
-  if (!/^(https?|wss?):\/\//i.test(url)) url = `http://${url}`
-  url = url.replace(/^ws:/i, 'http:').replace(/^wss:/i, 'https:')
-  return url.replace(/^http:/i, 'ws:').replace(/^https:/i, 'wss:')
-}
-
 /**
  * Build connect params for the OpenClaw gateway protocol.
  *
@@ -277,6 +278,121 @@ async function connectToGateway(
   return wsConnect(wsUrl, token, true, timeoutMs)
 }
 
+export function resolveGatewayAgentId(session: Record<string, unknown> & { id: string }): string {
+  const explicit = typeof session.openclawAgentId === 'string' && session.openclawAgentId.trim()
+    ? session.openclawAgentId.trim()
+    : ''
+  if (explicit) return normalizeOpenClawAgentId(explicit)
+
+  const agentId = typeof session.shortcutForAgentId === 'string' && session.shortcutForAgentId.trim()
+    ? session.shortcutForAgentId.trim()
+    : typeof session.agentId === 'string' && session.agentId.trim()
+      ? session.agentId.trim()
+      : ''
+  if (agentId) {
+    const agents = loadAgents({ includeTrashed: true })
+    const agent = agents[agentId] as { name?: string; provider?: string } | undefined
+    if (agent?.provider === 'openclaw' && typeof agent.name === 'string' && agent.name.trim()) {
+      return normalizeOpenClawAgentId(agent.name)
+    }
+  }
+
+  const sessionName = typeof session.name === 'string' && session.name.trim() ? session.name.trim() : ''
+  if (sessionName) return normalizeOpenClawAgentId(sessionName)
+  return 'main'
+}
+
+async function rpcOnConnectedGateway(
+  ws: InstanceType<typeof WebSocket>,
+  method: string,
+  params: unknown,
+  timeoutMs = 5_000,
+): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const requestId = randomUUID()
+    let settled = false
+
+    const cleanup = () => {
+      clearTimeout(timer)
+      ws.off('message', onMessage)
+      ws.off('close', onClose)
+      ws.off('error', onError)
+    }
+
+    const finish = (fn: () => void) => {
+      if (settled) return
+      settled = true
+      cleanup()
+      fn()
+    }
+
+    const onMessage = (data: unknown) => {
+      try {
+        const msg = JSON.parse(String(data))
+        if (msg.type !== 'res' || msg.id !== requestId) return
+        if (msg.ok) {
+          finish(() => resolve(msg.payload))
+        } else {
+          const message = typeof msg.error?.message === 'string'
+            ? msg.error.message
+            : `${method} failed`
+          finish(() => reject(new Error(message)))
+        }
+      } catch {
+        // Ignore unrelated or malformed frames while waiting for our response.
+      }
+    }
+
+    const onClose = () => finish(() => reject(new Error('Gateway closed before RPC completed')))
+    const onError = (err: Error) => finish(() => reject(err))
+    const timer = setTimeout(() => {
+      finish(() => reject(new Error(`${method} timed out`)))
+    }, timeoutMs)
+
+    ws.on('message', onMessage)
+    ws.on('close', onClose)
+    ws.on('error', onError)
+    ws.send(JSON.stringify({ type: 'req', id: requestId, method, params }))
+  })
+}
+
+async function resolveConnectedGatewayAgentId(
+  ws: InstanceType<typeof WebSocket>,
+  session: Record<string, unknown> & { id: string },
+): Promise<string> {
+  const fallback = resolveGatewayAgentId(session)
+  const explicitAgentId = typeof session.openclawAgentId === 'string' && session.openclawAgentId.trim()
+    ? session.openclawAgentId.trim()
+    : ''
+  const localAgentId = typeof session.shortcutForAgentId === 'string' && session.shortcutForAgentId.trim()
+    ? session.shortcutForAgentId.trim()
+    : typeof session.agentId === 'string' && session.agentId.trim()
+      ? session.agentId.trim()
+      : ''
+  const agentRef = explicitAgentId || localAgentId || fallback
+
+  try {
+    const payload = await rpcOnConnectedGateway(ws, 'agents.list', {})
+    const gatewayAgents = Array.isArray((payload as { agents?: unknown[] } | undefined)?.agents)
+      ? (payload as { agents: OpenClawGatewayAgentSummary[] }).agents
+      : []
+    if (gatewayAgents.length === 0) return fallback
+
+    const localAgents = localAgentId ? loadAgents({ includeTrashed: true }) : {}
+    const localAgent = localAgentId
+      ? (localAgents[localAgentId] as Agent | undefined) || null
+      : null
+
+    return resolveOpenClawGatewayAgentIdFromList({
+      agentRef,
+      gatewayAgents,
+      localAgent: localAgent?.provider === 'openclaw' ? localAgent : null,
+    }) || fallback
+  } catch {
+    return fallback
+  }
+}
+
 // --- Provider ---
 
 export function streamOpenClawChat({ session, message, imagePath, apiKey, write, active, signal }: StreamChatOptions): Promise<string> {
@@ -285,9 +401,8 @@ export function streamOpenClawChat({ session, message, imagePath, apiKey, write,
     prompt = `[The user has shared an image at: ${imagePath}]\n\n${message}`
   }
 
-  const wsUrl = session.apiEndpoint ? normalizeWsUrl(session.apiEndpoint) : 'ws://127.0.0.1:18789'
+  const wsUrl = session.apiEndpoint ? deriveOpenClawWsUrl(session.apiEndpoint) : 'ws://127.0.0.1:18789'
   const token = apiKey || session.apiKey || undefined
-
   return new Promise((resolve) => {
     let fullResponse = ''
     let settled = false
@@ -302,13 +417,14 @@ export function streamOpenClawChat({ session, message, imagePath, apiKey, write,
       resolve(fullResponse)
     }
 
-    connectToGateway(wsUrl, token).then((result) => {
+    connectToGateway(wsUrl, token).then(async (result) => {
       if (!result.ok || !result.ws) {
         finish(result.message)
         return
       }
 
       const ws = result.ws
+      const gatewayAgentId = await resolveConnectedGatewayAgentId(ws, session)
       const timeout = setTimeout(() => {
         ws.close()
         finish('OpenClaw gateway timed out after 120s.')
@@ -328,7 +444,7 @@ export function streamOpenClawChat({ session, message, imagePath, apiKey, write,
         method: 'agent',
         params: {
           message: prompt,
-          agentId: 'main',
+          agentId: gatewayAgentId,
           timeout: 120,
           idempotencyKey: randomUUID(),
         },