@bibobonking/opensol 0.0.0-stage → 3.0.2

package/src/App.tsx

@@ -0,0 +1,152 @@
+import { useEffect, useState } from 'react'
+import { Sidebar } from './components/Sidebar'
+import { ChatView } from './components/ChatView'
+import { WorkspacePanel } from './components/WorkspacePanel'
+import { SettingsModal } from './components/SettingsModal'
+import { DeployModal } from './components/DeployModal'
+import { CommandPalette } from './components/CommandPalette'
+import { Splash } from './components/Splash'
+import { ConfirmDialog, ToastHost } from './components/ui'
+import { useSettings } from './store/settings'
+import { useModelSync } from './store/models'
+import { useUi } from './store/ui'
+import { useBoot } from './lib/boot'
+import { resolveTheme, themeIsDark } from './lib/themes'
+import { listInstalledPlugins } from './lib/daemon'
+import { syncPlugins } from './plugins'
+
+const MIN_SPLASH_MS = 1600
+
+export default function App() {
+  const phase = useBoot((state) => state.phase)
+  const error = useBoot((state) => state.error)
+  const boot = useBoot((state) => state.boot)
+  const theme = useSettings((state) => state.theme)
+  const chatFontSize = useSettings((state) => state.chatFontSize)
+  const mobileSidebarOpen = useUi((state) => state.mobileSidebarOpen)
+  const setMobileSidebarOpen = useUi((state) => state.setMobileSidebarOpen)
+  const setPaletteOpen = useUi((state) => state.setPaletteOpen)
+
+  useModelSync()
+
+  // Keep the splash up for at least MIN_SPLASH_MS so the intro animation can play,
+  // then let it fade out over the app instead of cutting.
+  const [splash, setSplash] = useState<'show' | 'leaving' | 'gone'>('show')
+  useEffect(() => {
+    if (phase !== 'ready' || splash !== 'show') return
+    const started = useBoot.getState().startedAt || Date.now()
+    const wait = Math.max(0, MIN_SPLASH_MS - (Date.now() - started))
+    const t1 = window.setTimeout(() => setSplash('leaving'), wait)
+    return () => window.clearTimeout(t1)
+  }, [phase, splash])
+  useEffect(() => {
+    if (splash !== 'leaving') return
+    const t2 = window.setTimeout(() => setSplash('gone'), 520)
+    return () => window.clearTimeout(t2)
+  }, [splash])
+
+  useEffect(() => {
+    void boot()
+  }, [boot])
+
+  // Safe + enabled plugins are loaded once the app knows the daemon answered.
+  useEffect(() => {
+    if (phase !== 'ready') return
+    void listInstalledPlugins()
+      .then((result) => syncPlugins(result.plugins))
+      .catch(() => undefined)
+  }, [phase])
+
+  useEffect(() => {
+    const root = document.documentElement
+    const media = window.matchMedia('(prefers-color-scheme: dark)')
+    const apply = () => {
+      const resolved = resolveTheme(theme, media.matches)
+      root.dataset.theme = resolved
+      root.classList.toggle('dark', themeIsDark(theme, media.matches))
+      document
+        .querySelector('meta[name="theme-color"]')
+        ?.setAttribute('content', themeIsDark(theme, media.matches) ? '#141413' : '#ffffff')
+      try {
+        localStorage.setItem('opensol.theme', theme)
+      } catch {
+        // Storage can be unavailable in private mode; the theme still applies.
+      }
+    }
+    apply()
+    if (theme !== 'system') return
+    media.addEventListener('change', apply)
+    return () => media.removeEventListener('change', apply)
+  }, [theme])
+
+  useEffect(() => {
+    document.documentElement.style.setProperty('--chat-font-size', `${chatFontSize}px`)
+  }, [chatFontSize])
+
+  useEffect(() => {
+    const onKeyDown = (event: KeyboardEvent) => {
+      const mod = event.metaKey || event.ctrlKey
+      const key = event.key.toLowerCase()
+      if (mod && key === 'k') {
+        event.preventDefault()
+        setPaletteOpen(!useUi.getState().paletteOpen)
+        return
+      }
+      if (mod && !event.shiftKey && !event.altKey) {
+        if (key === 'b') {
+          event.preventDefault()
+          useUi.getState().toggleSidebar()
+          return
+        }
+        if (key === ',') {
+          event.preventDefault()
+          useUi.getState().openSettings('general')
+          return
+        }
+        if (key === '.') {
+          event.preventDefault()
+          const ui = useUi.getState()
+          ui.setWorkspaceOpen(!ui.workspaceOpen)
+          return
+        }
+      }
+      if (event.key === 'Escape' && useUi.getState().mobileSidebarOpen) {
+        setMobileSidebarOpen(false)
+      }
+    }
+    window.addEventListener('keydown', onKeyDown)
+    return () => window.removeEventListener('keydown', onKeyDown)
+  }, [setMobileSidebarOpen, setPaletteOpen])
+
+  const ready = phase === 'ready'
+
+  return (
+    <div className="flex h-dvh min-h-0 overflow-hidden bg-canvas text-ink">
+      {ready && (
+        <>
+          <Sidebar />
+          {mobileSidebarOpen && (
+            <button
+              type="button"
+              aria-label="Close sidebar"
+              onClick={() => setMobileSidebarOpen(false)}
+              className="modal-scrim fixed inset-0 z-40 cursor-default bg-black/30 backdrop-blur-[2px] lg:hidden"
+            />
+          )}
+          <div className="relative flex min-h-0 min-w-0 flex-1 bg-panel lg:my-1.5 lg:mr-1.5 lg:overflow-hidden lg:rounded-xl lg:border lg:border-line lg:shadow-pill">
+            <ChatView />
+            <WorkspacePanel />
+          </div>
+          <SettingsModal />
+          <DeployModal />
+          <CommandPalette />
+          <ConfirmDialog />
+        </>
+      )}
+      <ToastHost />
+      {splash !== 'gone' && (
+        <Splash phase={phase} error={error} leaving={splash === 'leaving'} onRetry={() => void boot(true)} />
+      )}
+    </div>
+  )
+}

package/src/agent/adapters/anthropic.ts

@@ -0,0 +1,233 @@
+import type { Message, ToolCall } from '../../types'
+import { requestLLM } from '../../lib/daemon'
+import { budgetForEffort, effortValues, hasBudget, normalizeEffort } from '../../lib/reasoning'
+import { readSSE } from '../../lib/sse'
+import { getToolSchemas } from '../tools'
+import {
+  assistantHistory,
+  imageAttachments,
+  parseToolArgs,
+  toolResultText,
+  userText,
+  type AdapterRequest,
+  type AdapterResult,
+} from './shared'
+
+type AnthropicBlock = Record<string, unknown>
+type AnthropicMessage = { role: 'user' | 'assistant'; content: AnthropicBlock[] }
+
+function buildMessages(history: Message[]): AnthropicMessage[] {
+  const messages: AnthropicMessage[] = []
+  const push = (role: 'user' | 'assistant', blocks: AnthropicBlock[]) => {
+    if (blocks.length === 0) return
+    const last = messages[messages.length - 1]
+    if (last?.role === role) last.content.push(...blocks)
+    else messages.push({ role, content: blocks })
+  }
+
+  for (const message of history) {
+    if (message.role === 'user') {
+      const blocks: AnthropicBlock[] = []
+      for (const image of imageAttachments(message)) {
+        const match = /^data:(image\/[a-z0-9.+-]+);base64,(.+)$/i.exec(image.dataUrl ?? '')
+        if (!match) continue
+        blocks.push({
+          type: 'image',
+          source: { type: 'base64', media_type: match[1], data: match[2] },
+        })
+      }
+      const text = userText(message)
+      if (text.trim()) blocks.push({ type: 'text', text })
+      if (blocks.length === 0) blocks.push({ type: 'text', text: '(empty message)' })
+      push('user', blocks)
+      continue
+    }
+
+    if (message.role === 'assistant') {
+      if (!assistantHistory(message)) continue
+      const blocks: AnthropicBlock[] = []
+      for (const thinking of message.thinkingBlocks ?? []) {
+        if (thinking.signature) {
+          blocks.push({ type: 'thinking', thinking: thinking.text, signature: thinking.signature })
+        }
+      }
+      if (message.content.trim()) blocks.push({ type: 'text', text: message.content })
+      for (const call of message.toolCalls) {
+        blocks.push({ type: 'tool_use', id: call.id, name: call.name, input: call.args })
+      }
+      push('assistant', blocks)
+      continue
+    }
+
+    push('user', [
+      {
+        type: 'tool_result',
+        tool_use_id: message.call.id,
+        content: toolResultText(message.result, message.status),
+        is_error: message.status === 'error' || message.status === 'denied',
+      },
+    ])
+  }
+
+  return messages
+}
+
+export async function streamAnthropic(request: AdapterRequest): Promise<AdapterResult> {
+  const { settings, model, history, system, mode, signal, handlers } = request
+  const modelId = settings.model.trim()
+  if (!modelId) throw new Error('Choose a model before sending a message.')
+
+  const efforts = effortValues(model)
+  const selectedEffort = normalizeEffort(settings.effort, model)
+  const thinkingRequested = selectedEffort !== 'none' && (efforts.length > 0 || hasBudget(model))
+
+  let maxTokens = settings.maxTokens
+  let budget = 0
+  if (thinkingRequested && efforts.length === 0 && hasBudget(model)) {
+    budget = budgetForEffort(selectedEffort, model)
+    maxTokens = Math.max(settings.maxTokens, budget + 1024)
+    if (model?.maxOutput) maxTokens = Math.min(maxTokens, model.maxOutput)
+    budget = Math.min(budget, maxTokens - 1024)
+    if (budget < 1024) budget = 0
+  }
+
+  const tools = getToolSchemas(settings, mode).map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.parameters,
+  }))
+
+  const body: Record<string, unknown> = {
+    model: modelId,
+    max_tokens: maxTokens,
+    system,
+    messages: buildMessages(history),
+    stream: true,
+  }
+  if (tools.length > 0) body.tools = tools
+  if (thinkingRequested && efforts.length > 0) {
+    // Anthropic output_config.effort only accepts: low, medium, high, xhigh, max
+    // Map unsupported values (none, minimal) to the closest valid value.
+    const anthropicEffort: string = selectedEffort === 'minimal' ? 'low' : selectedEffort
+    body.output_config = { effort: anthropicEffort }
+  } else if (budget > 0) {
+    body.thinking = { type: 'enabled', budget_tokens: budget }
+  } else if (!thinkingRequested) {
+    const supportsTemperature = model ? model.temperature : true
+    if (supportsTemperature) body.temperature = settings.temperature
+  }
+
+  const response = await requestLLM(settings.provider, 'anthropic', modelId, body, signal)
+
+  let content = ''
+  let reasoning = ''
+  let usage: AdapterResult['usage'] = {}
+  const blocks = new Map<
+    number,
+    {
+      type: string
+      text: string
+      signature: string
+      id: string
+      name: string
+      json: string
+      input: unknown
+    }
+  >()
+
+  for await (const data of readSSE(response)) {
+    let payload: Record<string, unknown>
+    try {
+      payload = JSON.parse(data) as Record<string, unknown>
+    } catch {
+      continue
+    }
+    const type = payload.type
+
+    if (type === 'error') {
+      const error = payload.error as { message?: string } | string | undefined
+      throw new Error(typeof error === 'string' ? error : (error?.message ?? 'Anthropic returned an error.'))
+    }
+
+    if (type === 'message_start') {
+      const message = payload.message as { usage?: { input_tokens?: number } } | undefined
+      usage = { ...usage, input: message?.usage?.input_tokens }
+      continue
+    }
+
+    if (type === 'content_block_start') {
+      const index = Number(payload.index ?? blocks.size)
+      const block = payload.content_block as Record<string, unknown>
+      blocks.set(index, {
+        type: String(block.type ?? ''),
+        text: typeof block.text === 'string' ? block.text : typeof block.thinking === 'string' ? block.thinking : '',
+        signature: typeof block.signature === 'string' ? block.signature : '',
+        id: typeof block.id === 'string' ? block.id : '',
+        name: typeof block.name === 'string' ? block.name : '',
+        json: '',
+        input: block.input,
+      })
+      continue
+    }
+
+    if (type === 'content_block_delta') {
+      const index = Number(payload.index ?? 0)
+      const entry = blocks.get(index)
+      const delta = payload.delta as Record<string, unknown> | undefined
+      if (!entry || !delta) continue
+      if (delta.type === 'text_delta' && typeof delta.text === 'string') {
+        entry.text += delta.text
+        content += delta.text
+        handlers.onText(delta.text)
+      } else if (delta.type === 'thinking_delta' && typeof delta.thinking === 'string') {
+        entry.text += delta.thinking
+        reasoning += delta.thinking
+        handlers.onReasoning(delta.thinking)
+      } else if (delta.type === 'signature_delta' && typeof delta.signature === 'string') {
+        entry.signature += delta.signature
+      } else if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
+        entry.json += delta.partial_json
+      }
+      continue
+    }
+
+    if (type === 'message_delta') {
+      const deltaUsage = payload.usage as { output_tokens?: number } | undefined
+      usage = { ...usage, output: deltaUsage?.output_tokens ?? usage.output }
+      handlers.onUsage(usage)
+      continue
+    }
+
+    if (type === 'message_stop') break
+  }
+
+  const availableTools = new Set<string>(tools.map((tool) => tool.name))
+  const toolCalls: ToolCall[] = []
+  const thinkingBlocks: Array<{ text: string; signature?: string }> = []
+  for (const [, block] of [...blocks.entries()].sort((a, b) => a[0] - b[0])) {
+    if (block.type === 'tool_use' && block.name) {
+      if (!availableTools.has(block.name)) {
+        throw new Error(`The model requested a tool that is not enabled: ${block.name}`)
+      }
+      const args = block.json
+        ? parseToolArgs(block.json, block.name)
+        : block.input && typeof block.input === 'object'
+          ? (block.input as Record<string, unknown>)
+          : {}
+      toolCalls.push({
+        id: block.id || `call_${Date.now().toString(36)}_${toolCalls.length}`,
+        name: block.name as ToolCall['name'],
+        args,
+      })
+    }
+    if (block.type === 'thinking' && block.text) {
+      thinkingBlocks.push({
+        text: block.text,
+        signature: block.signature || undefined,
+      })
+    }
+  }
+  if (toolCalls.length > 0) handlers.onToolCalls(toolCalls)
+
+  return { content, reasoning, toolCalls, thinkingBlocks, usage }
+}

package/src/agent/adapters/gemini.ts

@@ -0,0 +1,225 @@
+import type { Message, ToolCall } from '../../types'
+import { requestLLM } from '../../lib/daemon'
+import { budgetForEffort, effortValues, hasBudget, normalizeEffort, hasToggle } from '../../lib/reasoning'
+import { readSSE } from '../../lib/sse'
+import { getToolSchemas } from '../tools'
+import {
+  assistantHistory,
+  imageAttachments,
+  toolResultText,
+  userText,
+  type AdapterRequest,
+  type AdapterResult,
+} from './shared'
+
+interface GeminiContent {
+  role: 'user' | 'model'
+  parts: Array<Record<string, unknown>>
+}
+
+function buildContents(history: Message[]): GeminiContent[] {
+  const contents: GeminiContent[] = []
+  const push = (role: 'user' | 'model', parts: Array<Record<string, unknown>>) => {
+    if (parts.length === 0) return
+    const last = contents[contents.length - 1]
+    if (last?.role === role) last.parts.push(...parts)
+    else contents.push({ role, parts })
+  }
+
+  for (const message of history) {
+    if (message.role === 'user') {
+      const parts: Array<Record<string, unknown>> = []
+      for (const image of imageAttachments(message)) {
+        const match = /^data:([^;]+);base64,(.+)$/i.exec(image.dataUrl ?? '')
+        if (!match) continue
+        parts.push({ inlineData: { mimeType: match[1], data: match[2] } })
+      }
+      const text = userText(message)
+      if (text.trim()) parts.push({ text })
+      if (parts.length === 0) parts.push({ text: '(empty message)' })
+      push('user', parts)
+      continue
+    }
+
+    if (message.role === 'assistant') {
+      if (!assistantHistory(message)) continue
+      const parts: Array<Record<string, unknown>> = []
+      if (message.content.trim()) parts.push({ text: message.content })
+      for (const call of message.toolCalls) {
+        parts.push({
+          functionCall: { name: call.name, args: call.args },
+          ...(call.thoughtSignature ? { thoughtSignature: call.thoughtSignature } : {}),
+        })
+      }
+      push('model', parts)
+      continue
+    }
+
+    push('user', [
+      {
+        functionResponse: {
+          name: message.call.name,
+          response: {
+            result: toolResultText(message.result, message.status),
+            ...(message.status === 'error' || message.status === 'denied' ? { isError: true } : {}),
+          },
+        },
+      },
+    ])
+  }
+
+  return contents
+}
+
+function cleanSchema(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(cleanSchema)
+  if (!value || typeof value !== 'object') return value
+  const result: Record<string, unknown> = {}
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    if (key === 'additionalProperties' || key === '$schema') continue
+    result[key] = cleanSchema(entry)
+  }
+  return result
+}
+
+export async function streamGemini(request: AdapterRequest): Promise<AdapterResult> {
+  const { settings, model, history, system, mode, signal, handlers } = request
+  const modelId = settings.model.trim()
+  if (!modelId) throw new Error('Choose a model before sending a message.')
+
+  const efforts = effortValues(model)
+  const selectedEffort = normalizeEffort(settings.effort, model)
+  const budget = hasBudget(model) ? budgetForEffort(selectedEffort, model) : 0
+  const thinkingRequested = selectedEffort !== 'none' && (efforts.length > 0 || budget > 0)
+  let maxOutputTokens = settings.maxTokens
+  if (thinkingRequested && budget > 0) {
+    maxOutputTokens = Math.max(maxOutputTokens, budget + 2048)
+    if (model?.maxOutput) maxOutputTokens = Math.min(maxOutputTokens, model.maxOutput)
+  }
+
+  const tools = getToolSchemas(settings, mode)
+
+  const generationConfig: Record<string, unknown> = {
+    maxOutputTokens,
+  }
+  if (model ? model.temperature : true) generationConfig.temperature = settings.temperature
+  if (thinkingRequested && efforts.length > 0) {
+    // Gemini API requires UPPERCASE thinking level values: MINIMAL, LOW, MEDIUM, HIGH
+    generationConfig.thinkingConfig = { thinkingLevel: selectedEffort.toUpperCase(), includeThoughts: true }
+  } else if (thinkingRequested && budget > 0) {
+    generationConfig.thinkingConfig = {
+      thinkingBudget: Math.min(budget, Math.max(1024, maxOutputTokens - 1024)),
+      includeThoughts: true,
+    }
+  } else if (thinkingRequested && hasToggle(model)) {
+    generationConfig.thinkingConfig = { includeThoughts: true }
+  }
+
+  const body: Record<string, unknown> = {
+    systemInstruction: { parts: [{ text: system }] },
+    contents: buildContents(history),
+    generationConfig,
+  }
+  if (tools.length > 0) {
+    body.tools = [
+      {
+        functionDeclarations: tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          parameters: cleanSchema(tool.parameters),
+        })),
+      },
+    ]
+    body.toolConfig = { functionCallingConfig: { mode: 'AUTO' } }
+  }
+
+  const response = await requestLLM(settings.provider, 'gemini', modelId, body, signal)
+
+  let content = ''
+  let reasoning = ''
+  let usage: AdapterResult['usage'] = {}
+  let finishReason = ''
+  const calls: Array<{ name: string; args: Record<string, unknown>; signature?: string }> = []
+  const availableTools = new Set<string>(tools.map((tool) => tool.name))
+  let pendingSignature: string | undefined
+
+  for await (const data of readSSE(response)) {
+    let payload: Record<string, unknown>
+    try {
+      payload = JSON.parse(data) as Record<string, unknown>
+    } catch {
+      continue
+    }
+
+    const error = payload.error as { message?: string } | undefined
+    if (error?.message) throw new Error(error.message)
+
+    const feedback = payload.promptFeedback as { blockReason?: string } | undefined
+    if (feedback?.blockReason) {
+      throw new Error(`Gemini blocked this request (${feedback.blockReason}).`)
+    }
+
+    const usageMetadata = payload.usageMetadata as
+      | { promptTokenCount?: number; candidatesTokenCount?: number; thoughtsTokenCount?: number }
+      | undefined
+    if (usageMetadata) {
+      usage = {
+        input: usageMetadata.promptTokenCount,
+        output:
+          (usageMetadata.candidatesTokenCount ?? 0) + (usageMetadata.thoughtsTokenCount ?? 0) ||
+          usageMetadata.candidatesTokenCount,
+      }
+      handlers.onUsage(usage)
+    }
+
+    const candidates = payload.candidates as
+      | Array<{
+          content?: { parts?: Array<Record<string, unknown>> }
+          finishReason?: string
+        }>
+      | undefined
+    const candidate = candidates?.[0]
+    if (candidate?.finishReason) finishReason = candidate.finishReason
+    for (const part of candidate?.content?.parts ?? []) {
+      const partSignature = typeof part.thoughtSignature === 'string' ? part.thoughtSignature : undefined
+      if (partSignature) pendingSignature = partSignature
+      if (typeof part.text === 'string' && part.text) {
+        if (part.thought === true) {
+          reasoning += part.text
+          handlers.onReasoning(part.text)
+        } else {
+          content += part.text
+          handlers.onText(part.text)
+        }
+      }
+      const functionCall = part.functionCall as
+        | { name?: string; args?: Record<string, unknown> }
+        | undefined
+      if (functionCall?.name) {
+        if (!availableTools.has(functionCall.name as ToolCall['name'])) {
+          throw new Error(`Gemini requested a tool that is not enabled: ${functionCall.name}`)
+        }
+        calls.push({
+          name: functionCall.name,
+          args: functionCall.args ?? {},
+          signature: partSignature ?? pendingSignature,
+        })
+        pendingSignature = undefined
+      }
+    }
+  }
+
+  if (finishReason === 'SAFETY' || finishReason === 'RECITATION') {
+    throw new Error(`Gemini stopped the response (${finishReason.toLowerCase()}).`)
+  }
+
+  const toolCalls: ToolCall[] = calls.map((call, index) => ({
+    id: `gemini_${Date.now().toString(36)}_${index}`,
+    name: call.name as ToolCall['name'],
+    args: call.args,
+    thoughtSignature: call.signature,
+  }))
+  if (toolCalls.length > 0) handlers.onToolCalls(toolCalls)
+
+  return { content, reasoning, toolCalls, usage }
+}