@bibobonking/opensol 0.0.0-stage → 3.0.1

package/src/agent/adapters/openai-responses.ts

@@ -0,0 +1,215 @@
+import type { Message, ToolCall } from '../../types'
+import { requestLLM } from '../../lib/daemon'
+import { effortValues, 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'
+
+function buildInput(history: Message[]): Array<Record<string, unknown>> {
+  const input: Array<Record<string, unknown>> = []
+
+  for (const message of history) {
+    if (message.role === 'user') {
+      const images = imageAttachments(message)
+      const text = userText(message) || (images.length > 0 ? 'See the attached image.' : '')
+      if (!text.trim() && images.length === 0) continue
+      if (images.length === 0) {
+        input.push({ role: 'user', content: text })
+        continue
+      }
+      const content: Array<Record<string, unknown>> = [{ type: 'input_text', text }]
+      for (const image of images) {
+        content.push({ type: 'input_image', image_url: image.dataUrl, detail: 'auto' })
+      }
+      input.push({ role: 'user', content })
+      continue
+    }
+
+    if (message.role === 'assistant') {
+      if (!assistantHistory(message)) continue
+      if (message.content.trim()) {
+        input.push({ role: 'assistant', content: message.content })
+      }
+      for (const call of message.toolCalls) {
+        input.push({
+          type: 'function_call',
+          call_id: call.id,
+          name: call.name,
+          arguments: JSON.stringify(call.args),
+        })
+      }
+      continue
+    }
+
+    input.push({
+      type: 'function_call_output',
+      call_id: message.call.id,
+      output: toolResultText(message.result, message.status),
+    })
+  }
+
+  return input
+}
+
+interface PendingCall {
+  id: string
+  name: string
+  args: string
+  order: number
+}
+
+function itemRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : {}
+}
+
+export async function streamOpenAIResponses(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 tools = getToolSchemas(settings, mode)
+  const availableTools = new Set<string>(tools.map((tool) => tool.name))
+
+  const body: Record<string, unknown> = {
+    model: modelId,
+    instructions: system,
+    input: buildInput(history),
+    max_output_tokens: settings.maxTokens,
+    tool_choice: 'auto',
+  }
+  if (tools.length > 0) {
+    body.tools = tools.map((tool) => ({
+      type: 'function',
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+      strict: false,
+    }))
+  }
+
+  const efforts = effortValues(model)
+  const effort = efforts.length > 0 ? normalizeEffort(settings.effort, model) : 'none'
+  if (effort !== 'none') {
+    body.reasoning = { effort }
+  }
+
+  const response = await requestLLM(settings.provider, 'openai-responses', modelId, body, signal)
+
+  let content = ''
+  let reasoning = ''
+  let usage: AdapterResult['usage'] = {}
+  const calls = new Map<string, PendingCall>()
+  let order = 0
+
+  const upsertCall = (key: string, item: Record<string, unknown>) => {
+    const existing = calls.get(key)
+    const id = typeof item.call_id === 'string' ? item.call_id : existing?.id || key
+    const name = typeof item.name === 'string' ? item.name : existing?.name || ''
+    const args = typeof item.arguments === 'string' ? item.arguments : existing?.args || ''
+    calls.set(key, { id, name, args, order: existing?.order ?? order++ })
+  }
+
+  for await (const data of readSSE(response)) {
+    if (data === '[DONE]') break
+    let event: Record<string, unknown>
+    try {
+      event = JSON.parse(data) as Record<string, unknown>
+    } catch {
+      continue
+    }
+    const type = typeof event.type === 'string' ? event.type : ''
+
+    if (type === 'error' || type === 'response.failed') {
+      const detail = itemRecord(event.response).error ?? event.error ?? event.message
+      const error = itemRecord(detail)
+      throw new Error(
+        typeof detail === 'string'
+          ? detail
+          : typeof error.message === 'string'
+            ? error.message
+            : 'The model request failed.',
+      )
+    }
+
+    if (type === 'response.output_text.delta' && typeof event.delta === 'string') {
+      content += event.delta
+      handlers.onText(event.delta)
+      continue
+    }
+
+    if (
+      (type === 'response.reasoning_summary_text.delta' ||
+        type === 'response.reasoning_text.delta') &&
+      typeof event.delta === 'string'
+    ) {
+      reasoning += event.delta
+      handlers.onReasoning(event.delta)
+      continue
+    }
+
+    if (type === 'response.output_item.added') {
+      const item = itemRecord(event.item)
+      if (item.type === 'function_call') {
+        const key = typeof item.id === 'string' ? item.id : typeof item.call_id === 'string' ? item.call_id : ''
+        if (key) upsertCall(key, item)
+      }
+      continue
+    }
+
+    if (type === 'response.function_call_arguments.delta') {
+      const key = typeof event.item_id === 'string' ? event.item_id : ''
+      const entry = key ? calls.get(key) : undefined
+      if (entry && typeof event.delta === 'string') entry.args += event.delta
+      continue
+    }
+
+    if (type === 'response.function_call_arguments.done') {
+      const key = typeof event.item_id === 'string' ? event.item_id : ''
+      const entry = key ? calls.get(key) : undefined
+      if (entry && typeof event.arguments === 'string') entry.args = event.arguments
+      continue
+    }
+
+    if (type === 'response.output_item.done') {
+      const item = itemRecord(event.item)
+      if (item.type === 'function_call') {
+        const key = typeof item.id === 'string' ? item.id : typeof item.call_id === 'string' ? item.call_id : ''
+        if (key) upsertCall(key, item)
+      }
+      continue
+    }
+
+    if (type === 'response.completed') {
+      const done = itemRecord(event.response)
+      const value = itemRecord(done.usage)
+      if (typeof value.input_tokens === 'number' || typeof value.output_tokens === 'number') {
+        usage = { input: Number(value.input_tokens) || undefined, output: Number(value.output_tokens) || undefined }
+        handlers.onUsage(usage)
+      }
+    }
+  }
+
+  const toolCalls: ToolCall[] = []
+  const pending = [...calls.entries()].sort((a, b) => a[1].order - b[1].order)
+  for (const [key, call] of pending) {
+    if (!call.name) continue
+    if (!availableTools.has(call.name)) {
+      throw new Error(`The model requested a tool that is not enabled: ${call.name}`)
+    }
+    toolCalls.push({
+      id: call.id || key,
+      name: call.name as ToolCall['name'],
+      args: parseToolArgs(call.args, call.name),
+    })
+  }
+  if (toolCalls.length > 0) handlers.onToolCalls(toolCalls)
+
+  return { content, reasoning, toolCalls, usage }
+}

package/src/agent/adapters/openai.ts

@@ -0,0 +1,200 @@
+import type { Message, ToolCall } from '../../types'
+import { requestLLM } from '../../lib/daemon'
+import { effortValues, 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 OpenAIMessage = Record<string, unknown>
+
+function buildMessages(history: Message[]): OpenAIMessage[] {
+  const messages: OpenAIMessage[] = []
+
+  for (const message of history) {
+    if (message.role === 'user') {
+      const images = imageAttachments(message)
+      if (images.length > 0) {
+        const content: Array<Record<string, unknown>> = [
+          { type: 'text', text: userText(message) || 'See the attached image.' },
+        ]
+        for (const image of images) {
+          content.push({ type: 'image_url', image_url: { url: image.dataUrl, detail: 'auto' } })
+        }
+        messages.push({ role: 'user', content })
+      } else {
+        const text = userText(message)
+        if (text.trim()) messages.push({ role: 'user', content: text })
+      }
+      continue
+    }
+
+    if (message.role === 'assistant') {
+      if (!assistantHistory(message)) continue
+      const item: OpenAIMessage = {
+        role: 'assistant',
+        content: message.content || null,
+      }
+      if (message.toolCalls.length > 0) {
+        item.tool_calls = message.toolCalls.map((call) => ({
+          id: call.id,
+          type: 'function',
+          function: { name: call.name, arguments: JSON.stringify(call.args) },
+        }))
+      }
+      messages.push(item)
+      continue
+    }
+
+    messages.push({
+      role: 'tool',
+      tool_call_id: message.call.id,
+      content: toolResultText(message.result, message.status),
+    })
+  }
+
+  return messages
+}
+
+function usesCompletionTokens(provider: string, modelId: string) {
+  if (provider !== 'openai') return false
+  return /^(gpt-5|o[1-9]|codex)/i.test(modelId)
+}
+
+export async function streamOpenAI(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 tools = getToolSchemas(settings, mode)
+  const availableTools = new Set<string>(tools.map((tool) => tool.name))
+  const modelTools = tools.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+    },
+  }))
+
+  const body: Record<string, unknown> = {
+    model: modelId,
+    messages: [{ role: 'system', content: system }, ...buildMessages(history)],
+    stream: true,
+  }
+  if (modelTools.length > 0) {
+    body.tools = modelTools
+    body.tool_choice = 'auto'
+  }
+  if (settings.provider === 'openai' || settings.provider === 'openrouter') {
+    body.stream_options = { include_usage: true }
+  }
+  if (usesCompletionTokens(settings.provider, modelId)) {
+    body.max_completion_tokens = settings.maxTokens
+  } else {
+    body.max_tokens = settings.maxTokens
+  }
+
+  const efforts = effortValues(model)
+  let reasoningEffort = efforts.length > 0 ? normalizeEffort(settings.effort, model) : ''
+  if (reasoningEffort === 'none') reasoningEffort = ''
+  if (reasoningEffort) {
+    if (settings.provider === 'openrouter') body.reasoning = { effort: reasoningEffort }
+    else body.reasoning_effort = reasoningEffort
+  }
+
+  const supportsTemperature = model ? model.temperature : !usesCompletionTokens(settings.provider, modelId)
+  if (!reasoningEffort && supportsTemperature) body.temperature = settings.temperature
+
+  const response = await requestLLM(settings.provider, 'openai-chat', modelId, body, signal)
+
+  let content = ''
+  let reasoning = ''
+  let usage: AdapterResult['usage'] = {}
+  const toolAccumulator = new Map<number, { id: string; name: string; arguments: string }>()
+
+  for await (const data of readSSE(response)) {
+    if (data === '[DONE]') break
+    let payload: Record<string, unknown>
+    try {
+      payload = JSON.parse(data) as Record<string, unknown>
+    } catch {
+      continue
+    }
+
+    if (payload.error) {
+      const error = payload.error as { message?: string } | string
+      throw new Error(typeof error === 'string' ? error : (error.message ?? 'The provider returned an error.'))
+    }
+
+    if (payload.usage && typeof payload.usage === 'object') {
+      const value = payload.usage as { prompt_tokens?: number; completion_tokens?: number }
+      usage = { input: value.prompt_tokens, output: value.completion_tokens }
+      handlers.onUsage(usage)
+    }
+
+    const choices = payload.choices as
+      | Array<{
+          delta?: {
+            content?: string
+            reasoning?: string
+            reasoning_content?: string
+            reasoning_details?: Array<{ text?: string }>
+            tool_calls?: Array<{
+              index?: number
+              id?: string
+              function?: { name?: string; arguments?: string }
+            }>
+          }
+        }>
+      | undefined
+    const delta = choices?.[0]?.delta
+    if (!delta) continue
+
+    if (typeof delta.content === 'string' && delta.content) {
+      content += delta.content
+      handlers.onText(delta.content)
+    }
+    const reasoningDelta =
+      typeof delta.reasoning_content === 'string'
+        ? delta.reasoning_content
+        : typeof delta.reasoning === 'string'
+          ? delta.reasoning
+          : (delta.reasoning_details ?? []).map((item) => item.text ?? '').join('')
+    if (reasoningDelta) {
+      reasoning += reasoningDelta
+      handlers.onReasoning(reasoningDelta)
+    }
+
+    for (const [fallbackIndex, call] of (delta.tool_calls ?? []).entries()) {
+      const index = typeof call.index === 'number' ? call.index : fallbackIndex
+      const existing = toolAccumulator.get(index) ?? { id: '', name: '', arguments: '' }
+      if (call.id) existing.id = call.id
+      if (call.function?.name) existing.name = call.function.name
+      if (call.function?.arguments) existing.arguments += call.function.arguments
+      toolAccumulator.set(index, existing)
+    }
+  }
+
+  const toolCalls: ToolCall[] = []
+  for (const [index, call] of [...toolAccumulator.entries()].sort((a, b) => a[0] - b[0])) {
+    if (!call.name) continue
+    if (!availableTools.has(call.name)) {
+      throw new Error(`The model requested a tool that is not enabled: ${call.name}`)
+    }
+    toolCalls.push({
+      id: call.id || `call_${Date.now().toString(36)}_${index}`,
+      name: call.name as ToolCall['name'],
+      args: parseToolArgs(call.arguments, call.name),
+    })
+  }
+  if (toolCalls.length > 0) handlers.onToolCalls(toolCalls)
+
+  return { content, reasoning, toolCalls, usage }
+}

package/src/agent/adapters/shared.ts

@@ -0,0 +1,96 @@
+import type {
+  AgentMode,
+  AppSettings,
+  AssistantMessage,
+  Message,
+  ModelInfo,
+  StreamHandlers,
+  ToolCall,
+  Usage,
+} from '../../types'
+
+export interface AdapterRequest {
+  settings: AppSettings
+  model: ModelInfo | null
+  history: Message[]
+  system: string
+  mode: AgentMode
+  signal: AbortSignal
+  handlers: StreamHandlers
+}
+
+export interface AdapterResult {
+  content: string
+  reasoning: string
+  toolCalls: ToolCall[]
+  thinkingBlocks?: Array<{ text: string; signature?: string }>
+  usage: Usage
+}
+
+export const EMPTY_HANDLERS: StreamHandlers = {
+  onText: () => undefined,
+  onReasoning: () => undefined,
+  onToolCalls: () => undefined,
+  onUsage: () => undefined,
+}
+
+export function userText(message: Extract<Message, { role: 'user' }>): string {
+  const parts = [message.content]
+  for (const attachment of message.attachments ?? []) {
+    if (attachment.kind === 'text' && attachment.text) {
+      parts.push(`\n\n--- Attached file: ${attachment.name} ---\n${attachment.text}`)
+    }
+  }
+  return parts.filter(Boolean).join('')
+}
+
+export function assistantHistory(message: AssistantMessage): boolean {
+  return Boolean(message.content.trim() || message.toolCalls.length > 0)
+}
+
+export function imageAttachments(message: Extract<Message, { role: 'user' }>) {
+  return (message.attachments ?? []).filter(
+    (attachment) => attachment.kind === 'image' && attachment.dataUrl,
+  )
+}
+
+export function parseToolArgs(raw: string, toolName: string): Record<string, unknown> {
+  if (!raw.trim()) return {}
+  try {
+    const parsed = JSON.parse(raw) as unknown
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>
+    }
+    throw new Error('arguments must be a JSON object')
+  } catch (error) {
+    throw new Error(`The model returned invalid arguments for ${toolName}: ${(error as Error).message}`)
+  }
+}
+
+export function toolResultText(result: string | undefined, status: string): string {
+  if (status === 'done') return result ?? '(no output)'
+  if (status === 'denied') return 'The user denied this tool call.'
+  if (status === 'error') return `Tool error: ${result ?? 'unknown error'}`
+  if (status === 'awaiting') return 'The tool call was interrupted before approval.'
+  return result ?? '(no output)'
+}
+
+export function collectToolCalls(
+  candidates: Array<{ id: string; name: string; args: Record<string, unknown>; thoughtSignature?: string }>,
+  available: Set<string>,
+): ToolCall[] {
+  const calls: ToolCall[] = []
+  for (const candidate of candidates) {
+    if (!candidate.name) continue
+    if (!available.has(candidate.name)) {
+      throw new Error(`The model requested a tool that is not enabled: ${candidate.name}`)
+    }
+    calls.push({
+      id: candidate.id,
+      name: candidate.name as ToolCall['name'],
+      args: candidate.args,
+      ...(candidate.thoughtSignature ? { thoughtSignature: candidate.thoughtSignature } : {}),
+    })
+  }
+  return calls
+}

package/src/agent/approval.ts

@@ -0,0 +1,20 @@
+import { kernel } from '../core/kernel'
+import {
+  waitForApproval as coreWaitForApproval,
+  resolveApproval as coreResolveApproval,
+} from '../core/services/approval'
+
+export function waitForApproval(toolCallId: string, signal: AbortSignal): Promise<boolean> {
+  if (kernel.approval) {
+    return kernel.approval.waitForApproval(toolCallId, signal)
+  }
+  return coreWaitForApproval(toolCallId, signal)
+}
+
+export function resolveApproval(toolCallId: string, allow: boolean): void {
+  if (kernel.approval) {
+    kernel.approval.resolveApproval(toolCallId, allow)
+  } else {
+    coreResolveApproval(toolCallId, allow)
+  }
+}