@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/autonomy-contract.ts

@@ -0,0 +1,200 @@
+import type { GoalContract } from '@/types'
+
+const PLAN_LINE_RE = /\[MAIN_LOOP_PLAN\]\s*(\{[^\n]*\})/i
+const REVIEW_LINE_RE = /\[MAIN_LOOP_REVIEW\]\s*(\{[^\n]*\})/i
+
+export interface MainLoopPlanMeta {
+  steps?: string[]
+  current_step?: string
+}
+
+export interface MainLoopReviewMeta {
+  note?: string
+  confidence?: number
+  needs_replan?: boolean
+}
+
+function cleanText(value: string, max = 400): string {
+  return (value || '').replace(/\s+/g, ' ').trim().slice(0, max)
+}
+
+function uniqueStrings(input: string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const value of input) {
+    const normalized = cleanText(value, 240)
+    if (!normalized || seen.has(normalized.toLowerCase())) continue
+    seen.add(normalized.toLowerCase())
+    out.push(normalized)
+  }
+  return out
+}
+
+function safeJsonParse<T>(value: string): T | null {
+  try {
+    const parsed = JSON.parse(value)
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed as T
+  } catch {
+    // ignore malformed json
+  }
+  return null
+}
+
+function parseTaggedJsonLine<T>(text: string, tagRegex: RegExp): T | null {
+  const raw = (text || '').trim()
+  if (!raw) return null
+  const tagged = raw.match(tagRegex)?.[1]
+  if (tagged) {
+    const parsed = safeJsonParse<T>(tagged)
+    if (parsed) return parsed
+  }
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) continue
+    const parsed = safeJsonParse<T>(trimmed)
+    if (parsed) return parsed
+  }
+  return null
+}
+
+function parseBudgetUsd(text: string): number | null {
+  const patterns = [
+    /budget[^$\d]{0,20}\$?\s*(\d+(?:\.\d+)?)/i,
+    /\$\s*(\d+(?:\.\d+)?)/,
+    /(\d+(?:\.\d+)?)\s*(usd|dollars?)/i,
+  ]
+  for (const re of patterns) {
+    const m = text.match(re)
+    if (!m?.[1]) continue
+    const num = Number.parseFloat(m[1])
+    if (!Number.isFinite(num)) continue
+    return Math.max(0, Math.min(1_000_000, num))
+  }
+  return null
+}
+
+function parseDeadlineAt(text: string): number | null {
+  const patterns = [
+    /\bby\s+([A-Za-z]{3,10}\s+\d{1,2},?\s+\d{4})/i,
+    /\bby\s+(\d{4}-\d{2}-\d{2})/i,
+    /\bdeadline[^A-Za-z0-9]{0,8}([A-Za-z]{3,10}\s+\d{1,2},?\s+\d{4})/i,
+    /\bdeadline[^A-Za-z0-9]{0,8}(\d{4}-\d{2}-\d{2})/i,
+  ]
+  for (const re of patterns) {
+    const value = text.match(re)?.[1]
+    if (!value) continue
+    const ts = Date.parse(value)
+    if (!Number.isFinite(ts)) continue
+    return ts
+  }
+  return null
+}
+
+function parseSuccessMetric(text: string): string | null {
+  const patterns = [
+    /success(?:\s+is|\s+means|\s+metric)?\s*[:=-]\s*([^\n.]{4,180})/i,
+    /metric\s*[:=-]\s*([^\n.]{4,180})/i,
+    /kpi\s*[:=-]\s*([^\n.]{4,180})/i,
+  ]
+  for (const re of patterns) {
+    const value = cleanText(text.match(re)?.[1] || '', 180)
+    if (value) return value
+  }
+  return null
+}
+
+function parseObjective(text: string): string | null {
+  const direct = cleanText(text, 300)
+  if (!direct) return null
+  const firstSentence = direct.split(/(?<=[.!?])\s+/)[0]?.trim() || direct
+  return cleanText(firstSentence, 300) || null
+}
+
+function parseConstraints(text: string): string[] {
+  const constraints: string[] = []
+  const lines = text.split('\n').map((line) => line.trim()).filter(Boolean)
+  for (const line of lines) {
+    if (/^(must|should|avoid|without|do not|don't|within|under|limit)/i.test(line)) {
+      constraints.push(line.replace(/^[-*]\s*/, ''))
+      continue
+    }
+    if (/constraint[s]?\s*[:=-]/i.test(line)) {
+      const value = line.split(/[:=-]/).slice(1).join(':').trim()
+      if (value) constraints.push(value)
+    }
+  }
+  return uniqueStrings(constraints).slice(0, 8)
+}
+
+export function parseGoalContractFromText(text: string): GoalContract | null {
+  const objective = parseObjective(text || '')
+  if (!objective) return null
+  const constraints = parseConstraints(text || '')
+  const budgetUsd = parseBudgetUsd(text || '')
+  const deadlineAt = parseDeadlineAt(text || '')
+  const successMetric = parseSuccessMetric(text || '')
+  return {
+    objective,
+    constraints: constraints.length ? constraints : undefined,
+    budgetUsd: budgetUsd ?? null,
+    deadlineAt: deadlineAt ?? null,
+    successMetric: successMetric || null,
+  }
+}
+
+export function mergeGoalContracts(
+  current: GoalContract | null | undefined,
+  next: GoalContract | null | undefined,
+): GoalContract | null {
+  if (!current && !next) return null
+  if (!current) return next || null
+  if (!next) return current
+  return {
+    objective: next.objective || current.objective,
+    constraints: next.constraints?.length ? next.constraints : current.constraints,
+    budgetUsd: next.budgetUsd ?? current.budgetUsd ?? null,
+    deadlineAt: next.deadlineAt ?? current.deadlineAt ?? null,
+    successMetric: next.successMetric || current.successMetric || null,
+  }
+}
+
+export function parseMainLoopPlan(text: string): MainLoopPlanMeta | null {
+  const parsed = parseTaggedJsonLine<Record<string, unknown>>(text, PLAN_LINE_RE)
+  if (!parsed) return null
+  const steps = Array.isArray(parsed.steps)
+    ? uniqueStrings(parsed.steps.filter((v): v is string => typeof v === 'string')).slice(0, 8)
+    : []
+  const currentStep = typeof parsed.current_step === 'string'
+    ? cleanText(parsed.current_step, 220)
+    : ''
+  if (!steps.length && !currentStep) return null
+  return {
+    steps: steps.length ? steps : undefined,
+    current_step: currentStep || undefined,
+  }
+}
+
+export function parseMainLoopReview(text: string): MainLoopReviewMeta | null {
+  const parsed = parseTaggedJsonLine<Record<string, unknown>>(text, REVIEW_LINE_RE)
+  if (!parsed) return null
+  const note = typeof parsed.note === 'string' ? cleanText(parsed.note, 320) : ''
+  const confidenceRaw = typeof parsed.confidence === 'number'
+    ? parsed.confidence
+    : typeof parsed.confidence === 'string'
+      ? Number.parseFloat(parsed.confidence)
+      : Number.NaN
+  const confidence = Number.isFinite(confidenceRaw)
+    ? Math.max(0, Math.min(1, confidenceRaw))
+    : undefined
+  const needsReplan = parsed.needs_replan === true
+    ? true
+    : parsed.needs_replan === false
+      ? false
+      : undefined
+  if (!note && typeof confidence !== 'number' && typeof needsReplan !== 'boolean') return null
+  return {
+    note: note || undefined,
+    confidence,
+    needs_replan: needsReplan,
+  }
+}

package/src/lib/server/build-llm.ts

@@ -0,0 +1,155 @@
+import { ChatAnthropic } from '@langchain/anthropic'
+import { ChatOpenAI } from '@langchain/openai'
+import { loadCredentials, decryptKey, loadAgents, loadSettings } from './storage'
+import { getProviderList } from '../providers'
+import { normalizeOpenClawEndpoint } from '../openclaw-endpoint'
+
+const OLLAMA_CLOUD_URL = 'https://ollama.com/v1'
+const OLLAMA_LOCAL_URL = 'http://localhost:11434/v1'
+const NON_LANGGRAPH_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli'])
+
+/**
+ * Build a LangChain chat model from provider config.
+ * Uses the provider registry for endpoint defaults — no hardcoded provider list.
+ * Anthropic is the only special case (different LangChain class); everything else is OpenAI-compatible.
+ */
+export function buildChatModel(opts: {
+  provider: string
+  model: string
+  apiKey: string | null
+  apiEndpoint?: string | null
+}) {
+  const { provider, model, apiKey, apiEndpoint } = opts
+  const providers = getProviderList()
+  const providerInfo = providers.find((p) => p.id === provider)
+  const endpointRaw = apiEndpoint || providerInfo?.defaultEndpoint || null
+  const endpoint = provider === 'openclaw'
+    ? normalizeOpenClawEndpoint(endpointRaw)
+    : endpointRaw
+
+  if (provider === 'anthropic') {
+    return new ChatAnthropic({
+      model: model || 'claude-sonnet-4-6',
+      anthropicApiKey: apiKey || undefined,
+      maxTokens: 8192,
+    })
+  }
+
+  if (provider === 'ollama') {
+    const baseURL = apiKey && apiKey !== 'ollama'
+      ? OLLAMA_CLOUD_URL
+      : (endpoint ? `${endpoint}/v1` : OLLAMA_LOCAL_URL)
+    return new ChatOpenAI({
+      model: model || 'qwen3.5',
+      apiKey: apiKey || 'ollama',
+      configuration: { baseURL },
+    })
+  }
+
+  // All other providers — OpenAI-compatible with their registered endpoint
+  const config: any = { model: model || 'gpt-4o', apiKey: apiKey || undefined }
+  if (endpoint) {
+    config.configuration = { baseURL: endpoint }
+    // OpenClaw endpoints behind Hostinger's proxy use express.json() middleware
+    // which consumes the request body before http-proxy-middleware can forward it.
+    // Sending as text/plain bypasses the body parser while the gateway still parses JSON.
+    if (provider === 'openclaw') {
+      config.configuration.defaultHeaders = { 'Content-Type': 'text/plain' }
+    }
+  }
+  return config.configuration
+    ? new ChatOpenAI(config)
+    : new ChatOpenAI({ model: config.model, apiKey: config.apiKey })
+}
+
+function resolveApiKeyFromCredential(credentialId: string | null | undefined): string | null {
+  if (!credentialId) return null
+  const creds = loadCredentials()
+  const cred = creds[credentialId]
+  if (!cred?.encryptedKey) return null
+  try {
+    return decryptKey(cred.encryptedKey)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Build a LangChain LLM for generation tasks.
+ * Priority:
+ * 1) Settings -> Orchestrator Engine (if non-CLI provider configured)
+ * 2) Default agent (must be non-CLI)
+ */
+export async function buildLLM() {
+  const providers = getProviderList()
+  const settings = loadSettings()
+
+  const configuredProvider = typeof settings.langGraphProvider === 'string'
+    ? settings.langGraphProvider.trim()
+    : ''
+  const hasConfiguredProvider = configuredProvider.length > 0 && !NON_LANGGRAPH_PROVIDER_IDS.has(configuredProvider)
+
+  if (hasConfiguredProvider) {
+    const providerInfo = providers.find((p) => p.id === configuredProvider)
+    const model = (typeof settings.langGraphModel === 'string' && settings.langGraphModel.trim())
+      ? settings.langGraphModel.trim()
+      : providerInfo?.models?.[0] || ''
+    const apiKey = resolveApiKeyFromCredential(settings.langGraphCredentialId)
+    const apiEndpoint = (typeof settings.langGraphEndpoint === 'string' && settings.langGraphEndpoint.trim())
+      ? settings.langGraphEndpoint.trim()
+      : providerInfo?.defaultEndpoint || null
+
+    if (providerInfo?.requiresApiKey && !apiKey) {
+      throw new Error(`Orchestrator Engine provider "${providerInfo.name}" requires an API key. Configure one in Settings.`)
+    }
+
+    return {
+      llm: buildChatModel({
+        provider: configuredProvider,
+        model,
+        apiKey,
+        apiEndpoint,
+      }),
+      provider: configuredProvider,
+      model,
+    }
+  }
+
+  const agents = loadAgents()
+  const agent = agents.default as {
+    provider?: string
+    model?: string
+    credentialId?: string | null
+    apiEndpoint?: string | null
+  } | undefined
+
+  if (!agent) {
+    throw new Error('Default agent not found. Configure Orchestrator Engine in Settings.')
+  }
+
+  if (!agent.provider || NON_LANGGRAPH_PROVIDER_IDS.has(agent.provider)) {
+    throw new Error('Generate with AI requires a non-CLI provider. Configure Orchestrator Engine in Settings.')
+  }
+
+  const providerInfo = providers.find((p) => p.id === agent.provider)
+  const model = (typeof agent.model === 'string' && agent.model.trim())
+    ? agent.model.trim()
+    : providerInfo?.models?.[0] || ''
+  const apiKey = resolveApiKeyFromCredential(agent.credentialId)
+  const apiEndpoint = agent.apiEndpoint || providerInfo?.defaultEndpoint || null
+
+  if (providerInfo?.requiresApiKey && !apiKey) {
+    throw new Error(`Default agent provider "${providerInfo.name}" requires an API key.`)
+  }
+
+  return {
+    llm: buildChatModel({
+      provider: agent.provider,
+      model,
+      apiKey,
+      apiEndpoint: agent.apiEndpoint,
+    }),
+    provider: agent.provider as string,
+    model,
+  }
+}

package/src/lib/server/capability-router.test.ts

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { routeTaskIntent } from './capability-router.ts'
+
+test('routeTaskIntent keeps recall-style prompts as general intent', () => {
+  const decision = routeTaskIntent(
+    'What token did we store earlier as e2e_validation_token? Reply only with the token.',
+    ['memory', 'web_search'],
+    null,
+  )
+  assert.equal(decision.intent, 'general')
+})
+
+test('routeTaskIntent keeps coding prompts prioritized over memory keywords', () => {
+  const decision = routeTaskIntent(
+    'Build and test a calculator app, then remember the final path in memory.',
+    ['memory', 'shell', 'files'],
+    null,
+  )
+  assert.equal(decision.intent, 'coding')
+})

package/src/lib/server/capability-router.ts

@@ -0,0 +1,172 @@
+import type { AppSettings } from '@/types'
+
+export type TaskIntent =
+  | 'coding'
+  | 'research'
+  | 'browsing'
+  | 'outreach'
+  | 'scheduling'
+  | 'general'
+
+export interface CapabilityRoutingDecision {
+  intent: TaskIntent
+  confidence: number
+  preferredTools: string[]
+  preferredDelegates: Array<'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli'>
+  primaryUrl?: string
+}
+
+function findFirstUrl(text: string): string | undefined {
+  const m = text.match(/https?:\/\/[^\s<>"')]+/i)
+  return m?.[0]
+}
+
+function containsAny(text: string, terms: string[]): boolean {
+  return terms.some((term) => text.includes(term))
+}
+
+function normalizeDelegateOrder(
+  value: unknown,
+): Array<'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli'> {
+  const fallback: Array<'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli'> = [
+    'delegate_to_claude_code',
+    'delegate_to_codex_cli',
+    'delegate_to_opencode_cli',
+  ]
+  if (!Array.isArray(value) || !value.length) return fallback
+
+  const mapped: Array<'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli'> = []
+  for (const raw of value) {
+    if (raw === 'claude') mapped.push('delegate_to_claude_code')
+    else if (raw === 'codex') mapped.push('delegate_to_codex_cli')
+    else if (raw === 'opencode') mapped.push('delegate_to_opencode_cli')
+  }
+  if (!mapped.length) return fallback
+  const deduped = Array.from(new Set(mapped))
+  for (const tool of fallback) {
+    if (!deduped.includes(tool)) deduped.push(tool)
+  }
+  return deduped
+}
+
+export function routeTaskIntent(
+  message: string,
+  enabledTools: string[],
+  settings?: AppSettings | null,
+): CapabilityRoutingDecision {
+  const text = (message || '').toLowerCase()
+  const url = findFirstUrl(message || '')
+  const delegateOrder = normalizeDelegateOrder(settings?.autonomyPreferredDelegates)
+
+  const coding = containsAny(text, [
+    'build',
+    'implement',
+    'create app',
+    'refactor',
+    'fix bug',
+    'write code',
+    'codebase',
+    'typescript',
+    'javascript',
+    'react',
+    'next.js',
+    'unit test',
+    'run tests',
+    'compile',
+    'npm ',
+    'pnpm ',
+    'yarn ',
+  ])
+  if (coding) {
+    return {
+      intent: 'coding',
+      confidence: 0.9,
+      preferredTools: ['claude_code', 'codex_cli', 'opencode_cli', 'shell', 'files', 'edit_file'],
+      preferredDelegates: delegateOrder,
+      primaryUrl: url,
+    }
+  }
+
+  const outreach = containsAny(text, [
+    'send update',
+    'message',
+    'whatsapp',
+    'telegram',
+    'slack',
+    'discord',
+    'notify',
+    'broadcast',
+  ])
+  if (outreach) {
+    return {
+      intent: 'outreach',
+      confidence: 0.8,
+      preferredTools: ['connector_message_tool', 'manage_connectors', 'manage_sessions'],
+      preferredDelegates: delegateOrder,
+      primaryUrl: url,
+    }
+  }
+
+  const scheduling = containsAny(text, [
+    'schedule',
+    'every day',
+    'every week',
+    'cron',
+    'recurring',
+    'remind',
+    'follow up tomorrow',
+  ])
+  if (scheduling) {
+    return {
+      intent: 'scheduling',
+      confidence: 0.75,
+      preferredTools: ['manage_schedules', 'manage_tasks'],
+      preferredDelegates: delegateOrder,
+      primaryUrl: url,
+    }
+  }
+
+  const browsing = !!url && (
+    containsAny(text, ['browser', 'click', 'fill form', 'log in', 'screenshot', 'navigate'])
+    || enabledTools.includes('browser')
+  )
+  if (browsing) {
+    return {
+      intent: 'browsing',
+      confidence: 0.7,
+      preferredTools: ['browser', 'web_fetch'],
+      preferredDelegates: delegateOrder,
+      primaryUrl: url,
+    }
+  }
+
+  const research = containsAny(text, [
+    'research',
+    'look up',
+    'find out',
+    'search for',
+    'compare',
+    'latest',
+    'news',
+    'wikipedia',
+    'summarize this url',
+    'analyze website',
+  ]) || !!url
+  if (research) {
+    return {
+      intent: 'research',
+      confidence: 0.7,
+      preferredTools: ['web_search', 'web_fetch', 'browser'],
+      preferredDelegates: delegateOrder,
+      primaryUrl: url,
+    }
+  }
+
+  return {
+    intent: 'general',
+    confidence: 0.5,
+    preferredTools: [],
+    preferredDelegates: delegateOrder,
+    primaryUrl: url,
+  }
+}