ethagent 3.0.2 → 3.1.0

package/src/models/modelPickerLocalRunnerFlow.ts

@@ -0,0 +1,115 @@
+import type {
+  LlamaCppInstallProgress,
+  LlamaCppInstallResult,
+  LlamaCppStartResult,
+} from './llamacpp.js'
+import {
+  installLlamaCppRunner,
+  setLlamaCppServerPath,
+  startLlamaCppServer,
+} from './llamacpp.js'
+import type { LocalHfModel } from './huggingface.js'
+import type { ModelPickerSelection, ModelPickerState as State } from './modelPickerTypes.js'
+import { loadHfPickerModels, probeLlamaCpp } from './modelPickerData.js'
+export function localRunnerStartFailureSubtitle(result: Extract<LlamaCppStartResult, { ok: false }>): string {
+  switch (result.code) {
+    case 'readiness-timeout':
+      return 'the local runner is still loading or did not answer in time'
+    case 'runner-exited':
+      return 'the local runner closed before becoming ready'
+    case 'spawn-failed':
+      return 'the local runner could not be started'
+    case 'different-model-running':
+      return result.message
+    case 'model-file-missing':
+      return result.message
+    case 'runner-not-installed':
+      return 'this machine still needs a local runner'
+  }
+}
+
+export async function startAndPickHfModel(
+  model: LocalHfModel,
+  state: Extract<State, { kind: 'list' | 'localCatalog' | 'hfDone' | 'mmprojOffer' | 'mmprojError' }>,
+  setState: (s: State) => void,
+  onPick: (sel: ModelPickerSelection) => void,
+): Promise<void> {
+  if (model.risk === 'high') {
+    setState({ kind: 'hfError', data: state.data, message: 'blocked high-risk model; choose a model from a more credible source' })
+    return
+  }
+  if (model.mmprojAvailable && !model.mmprojPath && state.kind !== 'mmprojOffer' && state.kind !== 'mmprojError') {
+    setState({ kind: 'mmprojOffer', data: state.data, model })
+    return
+  }
+  setState({ kind: 'localRunnerStarting', data: state.data, model, startedAt: Date.now() })
+  const result = await startLlamaCppServer({
+    modelPath: model.localPath,
+    modelAlias: model.id,
+    mmprojPath: model.mmprojPath,
+  })
+  const llamaCpp = await probeLlamaCpp()
+  const data = { ...state.data, llamaCpp }
+  if (!result.ok) {
+    if (result.code === 'runner-not-installed') {
+      setState({ kind: 'localRunnerSetup', data, model })
+      return
+    }
+    setState({ kind: 'localRunnerStartFail', data, model, result })
+    return
+  }
+  onPick({ kind: 'llamacpp', model: model.id, mmprojPath: model.mmprojPath })
+}
+
+export async function installRunnerAndStart(
+  state: Extract<State, { kind: 'localRunnerSetup' }>,
+  setState: (s: State) => void,
+  onPick: (sel: ModelPickerSelection) => void,
+): Promise<void> {
+  await runRunnerSetup(state, setState, onPick, installLlamaCppRunner)
+}
+
+export async function runRunnerSetup(
+  state: Extract<State, { kind: 'localRunnerSetup' }>,
+  setState: (s: State) => void,
+  onPick: (sel: ModelPickerSelection) => void,
+  setup: (onProgress?: (progress: LlamaCppInstallProgress) => void) => Promise<LlamaCppInstallResult>,
+): Promise<void> {
+  const startedAt = Date.now()
+  const initialProgress: LlamaCppInstallProgress = {
+    phase: 'checking',
+    label: 'preparing local runner...',
+    progress: 0.04,
+  }
+  const updateProgress = (progress: LlamaCppInstallProgress): void => {
+    setState({ kind: 'localRunnerInstalling', data: state.data, model: state.model, startedAt, progress })
+  }
+
+  setState({ kind: 'localRunnerInstalling', data: state.data, model: state.model, startedAt, progress: initialProgress })
+  const result = await setup(updateProgress)
+  if (!result.ok) {
+    setState({ kind: 'localRunnerInstallFail', data: state.data, model: state.model, result })
+    return
+  }
+  await startAndPickHfModel(state.model, { kind: 'hfDone', data: state.data, model: state.model }, setState, onPick)
+}
+
+export async function saveRunnerPathAndStart(
+  state: Extract<State, { kind: 'localRunnerPathEntry' }>,
+  value: string,
+  setState: (s: State) => void,
+  onPick: (sel: ModelPickerSelection) => void,
+): Promise<void> {
+  const runnerPath = value.trim().replace(/^"|"$/g, '')
+  if (!runnerPath) {
+    setState({ ...state, error: 'paste the full path to llama-server' })
+    return
+  }
+  setState({ ...state, submitting: true, error: undefined })
+  try {
+    await setLlamaCppServerPath(runnerPath)
+    await startAndPickHfModel(state.model, { kind: 'hfDone', data: state.data, model: state.model }, setState, onPick)
+  } catch (err: unknown) {
+    setState({ ...state, submitting: false, error: (err as Error).message })
+  }
+}

package/src/models/modelPickerTypes.ts

@@ -0,0 +1,69 @@
+import type { EthagentConfig, ProviderId } from '../storage/config.js'
+import type {
+  LlamaCppInstallProgress,
+  LlamaCppInstallResult,
+  LlamaCppStartResult,
+} from './llamacpp.js'
+import type {
+  HfDownloadPlan,
+  HfDownloadProgress,
+  HuggingFaceRepoInfo,
+  HuggingFaceSibling,
+  LocalHfModel,
+} from './huggingface.js'
+import type {
+  CloudProviderId,
+  ModelPickerContextFit,
+  ModelPickerOptionsData,
+} from './modelPickerOptions.js'
+
+export type ModelPickerSelection =
+  | { kind: 'llamacpp'; model: string; mmprojPath?: string }
+  | { kind: 'cloud'; provider: CloudProviderId; model: string; keyJustSet: boolean }
+
+export type ModelPickerProps = {
+  currentConfig: EthagentConfig
+  currentProvider: ProviderId
+  currentModel: string
+  contextFit?: ModelPickerContextFit | null
+  featuredHfRepo?: string
+  localOnly?: boolean
+  onPick: (selection: ModelPickerSelection) => void
+  onCancel: () => void
+}
+
+export type LoadedModelPickerData = ModelPickerOptionsData
+export type LocalUninstallTarget = { kind: 'hf'; id: string; displayName: string; sizeBytes: number }
+
+export type ModelPickerState =
+  | { kind: 'loading' }
+  | { kind: 'list'; data: LoadedModelPickerData }
+  | { kind: 'localCatalogLoading'; data: LoadedModelPickerData }
+  | { kind: 'localCatalog'; data: LoadedModelPickerData; catalog: import('./uncensoredCatalog.js').UncensoredCatalogEntry[] }
+  | { kind: 'localCatalogError'; data: LoadedModelPickerData; message: string }
+  | { kind: 'catalog'; provider: CloudProviderId; data: LoadedModelPickerData }
+  | { kind: 'keyEntry'; provider: CloudProviderId; action: 'set' | 'edit'; data: LoadedModelPickerData; submitting: boolean; error?: string }
+  | { kind: 'keyManage'; provider: CloudProviderId; data: LoadedModelPickerData; submitting: boolean; error?: string }
+  | { kind: 'oauthManage'; data: LoadedModelPickerData; submitting: boolean; error?: string }
+  | { kind: 'oauthLogin'; data: LoadedModelPickerData; phase: 'waiting' | 'exchanging' | 'error'; url?: string; message?: string }
+  | { kind: 'hfInput'; data: LoadedModelPickerData; error?: string }
+  | { kind: 'hfLoading'; data: LoadedModelPickerData; input: string }
+  | { kind: 'hfFilePick'; data: LoadedModelPickerData; input: string; repo: HuggingFaceRepoInfo; files: HuggingFaceSibling[] }
+  | { kind: 'hfReview'; data: LoadedModelPickerData; plan: HfDownloadPlan }
+  | { kind: 'hfDownloading'; data: LoadedModelPickerData; plan: HfDownloadPlan; progress: HfDownloadProgress }
+  | { kind: 'hfDone'; data: LoadedModelPickerData; model: LocalHfModel; alreadyInstalled?: boolean }
+  | { kind: 'hfError'; data: LoadedModelPickerData; message: string; input?: string }
+  | { kind: 'localUninstallPick'; data: LoadedModelPickerData }
+  | { kind: 'localUninstallConfirm'; data: LoadedModelPickerData; target: LocalUninstallTarget }
+  | { kind: 'localUninstalling'; data: LoadedModelPickerData; target: LocalUninstallTarget }
+  | { kind: 'localUninstallDone'; data: LoadedModelPickerData; modelName: string }
+  | { kind: 'localUninstallError'; data: LoadedModelPickerData; target: LocalUninstallTarget; message: string }
+  | { kind: 'localRunnerSetup'; data: LoadedModelPickerData; model: LocalHfModel }
+  | { kind: 'localRunnerInstalling'; data: LoadedModelPickerData; model: LocalHfModel; startedAt: number; progress: LlamaCppInstallProgress }
+  | { kind: 'localRunnerInstallFail'; data: LoadedModelPickerData; model: LocalHfModel; result: Extract<LlamaCppInstallResult, { ok: false }> }
+  | { kind: 'localRunnerPathEntry'; data: LoadedModelPickerData; model: LocalHfModel; submitting: boolean; error?: string }
+  | { kind: 'localRunnerStarting'; data: LoadedModelPickerData; model: LocalHfModel; startedAt: number }
+  | { kind: 'localRunnerStartFail'; data: LoadedModelPickerData; model: LocalHfModel; result: Extract<LlamaCppStartResult, { ok: false }> }
+  | { kind: 'mmprojOffer'; data: LoadedModelPickerData; model: LocalHfModel }
+  | { kind: 'mmprojDownloading'; data: LoadedModelPickerData; model: LocalHfModel; progress: HfDownloadProgress }
+  | { kind: 'mmprojError'; data: LoadedModelPickerData; model: LocalHfModel; message: string }

package/src/models/modelPickerUninstallFlow.ts

@@ -0,0 +1,48 @@
+import type { ProviderId } from '../storage/config.js'
+import { uninstallLocalHfModel } from './huggingface.js'
+import { formatLocalHfModelDisplayName } from './modelDisplay.js'
+import type { LoadedModelPickerData as LoadedData, LocalUninstallTarget, ModelPickerState as State } from './modelPickerTypes.js'
+import { refreshLocalModelData } from './modelPickerData.js'
+export function localUninstallTargets(data: LoadedData): LocalUninstallTarget[] {
+  return data.hfModels.map(model => ({
+    kind: 'hf' as const,
+    id: model.id,
+    displayName: formatLocalHfModelDisplayName(model.id, {
+      displayName: model.displayName,
+      maxLength: 64,
+    }),
+    sizeBytes: model.sizeBytes,
+  }))
+}
+
+export function isCurrentLocalUninstallTarget(
+  target: LocalUninstallTarget,
+  currentProvider: ProviderId,
+  currentModel: string,
+): boolean {
+  return target.kind === 'hf' && currentProvider === 'llamacpp' && target.id === currentModel
+}
+
+export function localUninstallBoundaryCopy(_target: LocalUninstallTarget): string {
+  return 'This removes only the downloaded GGUF file and metadata from this machine.'
+}
+
+export async function uninstallLocalModel(
+  state: Extract<State, { kind: 'localUninstallConfirm' }>,
+  setState: (s: State) => void,
+): Promise<void> {
+  setState({ kind: 'localUninstalling', data: state.data, target: state.target })
+  const modelName = state.target.displayName
+  try {
+    await uninstallLocalHfModel(state.target.id)
+    const data = await refreshLocalModelData(state.data)
+    setState({ kind: 'localUninstallDone', data, modelName })
+  } catch (err: unknown) {
+    setState({
+      kind: 'localUninstallError',
+      data: state.data,
+      target: state.target,
+      message: (err as Error).message,
+    })
+  }
+}

package/src/models/modelPickerViewHelpers.ts

@@ -0,0 +1,174 @@
+import type { SelectOption } from '../ui/Select.js'
+import type { ProviderId } from '../storage/config.js'
+import { defaultModelFor, type EthagentConfig } from '../storage/config.js'
+import type { LlamaCppInstallResult } from './llamacpp.js'
+import { orderGgufFilesForSpec, type GgufMachineFit } from './modelRecommendation.js'
+import {
+  localModelId,
+  type HuggingFaceRepoInfo,
+  type HuggingFaceSibling,
+} from './huggingface.js'
+import {
+  MODEL_PICKER_CLOUD_PROVIDERS,
+  orderModelsForContextFit,
+  type CloudProviderId,
+  type ModelPickerContextFit,
+} from './modelPickerOptions.js'
+import { formatModelDisplayName } from './modelDisplay.js'
+import { contextFitLabel, formatBytes, modelMetadataSubtext } from './modelPickerDisplay.js'
+import type { LoadedModelPickerData as LoadedData, ModelPickerSelection } from './modelPickerTypes.js'
+import type { ModelCatalogResult } from './catalog.js'
+import type { SpecSnapshot } from './runtimeDetection.js'
+
+export function buildCatalogOptions(
+  provider: CloudProviderId,
+  catalog: ModelCatalogResult | undefined,
+  currentProvider: ProviderId,
+  currentModel: string,
+  contextFit?: ModelPickerContextFit | null,
+): SelectOption<string>[] {
+  if (!catalog || catalog.entries.length === 0) {
+    return [{
+      value: `hdr:catalog-empty:${provider}`,
+      label: 'No Models Found',
+      disabled: true,
+      role: 'notice',
+      prefix: 'note',
+    }]
+  }
+  const sourceById = new Map(catalog.entries.map(entry => [entry.id, entry.source]))
+  return orderModelsForContextFit(provider, catalog.entries.map(entry => entry.id), contextFit).map(id => {
+    const active = currentProvider === provider && currentModel === id
+    const suffix = sourceById.get(id) === 'fallback' ? '  fallback' : ''
+    const displayName = formatModelDisplayName(provider, id, { maxLength: 64 })
+    return {
+      value: `full:${provider}:${id}`,
+      label: contextFitLabel(provider, id, `${displayName}${active ? '  *' : ''}${suffix}`, contextFit),
+      role: 'option',
+    }
+  })
+}
+
+export function parseCloudValue(value: string): { provider: CloudProviderId; model: string } | null {
+  if (!value.startsWith('c:')) return null
+  const rest = value.slice(2)
+  const sep = rest.indexOf(':')
+  if (sep === -1) return null
+  const provider = rest.slice(0, sep)
+  const model = rest.slice(sep + 1)
+  if (!isCloudProvider(provider) || !model) return null
+  return { provider, model }
+}
+
+export function localModelOptionIndex(
+  options: SelectOption<string>[],
+  currentProvider: ProviderId,
+  currentModel: string,
+): number {
+  return options.findIndex(opt => {
+    if (opt.disabled) return false
+    if (opt.value.startsWith('hf:')) return opt.value.slice(3) === currentModel && currentProvider === 'llamacpp'
+    if (opt.value.startsWith('uc:')) return opt.value.slice(3) === currentModel && currentProvider === 'llamacpp'
+    return false
+  })
+}
+
+export function localOrCloudOptionIndex(
+  options: SelectOption<string>[],
+  currentProvider: ProviderId,
+  currentModel: string,
+): number {
+  return options.findIndex(opt => {
+    if (opt.disabled) return false
+    if (opt.value.startsWith('hf:')) return opt.value.slice(3) === currentModel && currentProvider === 'llamacpp'
+    if (opt.value.startsWith('uc:')) return opt.value.slice(3) === currentModel && currentProvider === 'llamacpp'
+    const cloud = parseCloudValue(opt.value)
+    return cloud?.provider === currentProvider && cloud.model === currentModel
+  })
+}
+
+export function parseFullCatalogValue(value: string): { provider: CloudProviderId; model: string } | null {
+  if (!value.startsWith('full:')) return null
+  const rest = value.slice(5)
+  const sep = rest.indexOf(':')
+  if (sep === -1) return null
+  const provider = rest.slice(0, sep)
+  const model = rest.slice(sep + 1)
+  if (!isCloudProvider(provider) || !model) return null
+  return { provider, model }
+}
+
+export function parseKeyValue(value: string): { action: 'set' | 'edit' | 'manage'; provider: CloudProviderId } | null {
+  if (!value.startsWith('key:')) return null
+  const parts = value.split(':')
+  if (parts.length !== 3) return null
+  const action = parts[1]
+  const provider = parts[2]
+  if (action !== 'set' && action !== 'edit' && action !== 'manage') return null
+  if (!provider) return null
+  if (!isCloudProvider(provider)) return null
+  return { action, provider }
+}
+
+export function pickFallbackSelection(data: LoadedData, removed: ProviderId): ModelPickerSelection | null {
+  for (const provider of MODEL_PICKER_CLOUD_PROVIDERS) {
+    if (provider === removed) continue
+    if (data.cloudKeys[provider] !== true) continue
+    const catalogModel = data.cloudCatalogs[provider]?.entries[0]?.id
+    const model = catalogModel ?? defaultModelFor(provider)
+    return { kind: 'cloud', provider, model, keyJustSet: false }
+  }
+  if (data.hfModels.length > 0) {
+    return { kind: 'llamacpp', model: data.hfModels[0]!.id }
+  }
+  return null
+}
+
+export function configForProvider(config: EthagentConfig, provider: CloudProviderId): EthagentConfig {
+  return {
+    ...config,
+    provider,
+    model: config.provider === provider ? config.model : defaultModelFor(provider),
+    baseUrl: provider === 'openai' && config.provider === 'openai' ? config.baseUrl : undefined,
+  }
+}
+
+export function buildHfFileOptions(
+  repo: HuggingFaceRepoInfo,
+  files: HuggingFaceSibling[],
+  spec: SpecSnapshot | undefined,
+  installedModelIds: string[] = [],
+): SelectOption<string>[] {
+  const ordered = spec
+    ? orderGgufFilesForSpec(repo, files, spec)
+    : files.map(file => ({ file, fit: 'unknown' as GgufMachineFit, score: 0, budgetBytes: 0 }))
+  const recommended = spec ? ordered[0]?.file.filename : undefined
+  const installed = new Set(installedModelIds)
+  return ordered.map(item => {
+    const size = item.file.sizeBytes ? formatBytes(item.file.sizeBytes) : ''
+    const indicators = [
+      item.file.filename === recommended ? 'Recommended' : '',
+      installed.has(localModelId(repo.repoId, item.file.filename)) ? 'Installed' : '',
+    ]
+    return {
+      value: item.file.filename,
+      label: item.file.filename,
+      subtext: modelMetadataSubtext(size, indicators),
+      role: 'option' as const,
+    }
+  })
+}
+
+export function buildRunnerRecoveryOptions(
+  _result: Extract<LlamaCppInstallResult, { ok: false }>,
+): SelectOption<'stop-and-retry' | 'path' | 'back'>[] {
+  return [
+    { value: 'stop-and-retry', label: 'Stop and Retry', hint: 'Stop background runners and try the install again' },
+    { value: 'path', label: 'Use Existing Runner Path' },
+    { value: 'back', label: 'Back To Picker' },
+  ]
+}
+
+function isCloudProvider(value: string): value is CloudProviderId {
+  return MODEL_PICKER_CLOUD_PROVIDERS.includes(value as CloudProviderId)
+}

package/src/providers/openai-chat.ts

@@ -1,12 +1,14 @@
 import type { ProviderId } from '../storage/config.js'
-import type { Message, MessageContentBlock, Provider, ProviderCompleteOptions, StreamEvent } from './contracts.js'
+import type { Message, Provider, ProviderCompleteOptions, StreamEvent } from './contracts.js'
 import { ProviderError } from './contracts.js'
 import { providerErrorFromResponse } from './errors.js'
 import { fetchWithRetryStreamEvents } from './retry.js'
 import { iterSseFrames } from './sse.js'
-import { messageTextContent } from '../utils/messages.js'
-import { hasImageBlocks, ImageLoadError, loadImageBlock } from '../utils/images.js'
+import { hasImageBlocks, ImageLoadError } from '../utils/images.js'
 import { providerDisplayName } from '../models/providerDisplay.js'
+import { toWireMessages } from './openaiChatWire.js'
+
+export { toWireMessages } from './openaiChatWire.js'
 
 export type OpenAIToolDefinition = {
   type: 'function'
@@ -270,91 +272,6 @@ export class OpenAIChatProvider implements Provider {
 
 }
 
-export async function toWireMessages(messages: Message[]): Promise<Array<Record<string, unknown>>> {
-  const out: Array<Record<string, unknown>> = []
-
-  for (const message of messages) {
-    if (typeof message.content === 'string') {
-      out.push({ role: message.role, content: message.content })
-      continue
-    }
-
-    if (message.role === 'user') {
-      const toolResults = message.content.filter(isToolResultBlock)
-      if (toolResults.length > 0) {
-        for (const block of toolResults) {
-          out.push({
-            role: 'tool',
-            tool_call_id: block.toolUseId,
-            content: block.content,
-          })
-        }
-        const nonToolBlocks = message.content.filter(block => block.type !== 'tool_result')
-        if (nonToolBlocks.length > 0) {
-          out.push({ role: 'user', content: await toOpenAIUserContent(nonToolBlocks) })
-        }
-        continue
-      }
-      out.push({ role: 'user', content: await toOpenAIUserContent(message.content) })
-      continue
-    }
-
-    if (message.role === 'assistant') {
-      const textParts = message.content.filter(isTextBlock).map(block => block.text)
-      const toolCalls = message.content.filter(isToolUseBlock).map(block => ({
-        id: block.id,
-        type: 'function',
-        function: {
-          name: block.name,
-          arguments: JSON.stringify(block.input),
-        },
-      }))
-      out.push({
-        role: 'assistant',
-        content: textParts.join(''),
-        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-      })
-      continue
-    }
-
-    const toolResults = message.content.filter(isToolResultBlock)
-    if (toolResults.length > 0) {
-      for (const block of toolResults) {
-        out.push({
-          role: 'tool',
-          tool_call_id: block.toolUseId,
-          content: block.content,
-        })
-      }
-      continue
-    }
-
-    out.push({ role: message.role, content: messageTextContent(message) })
-  }
-
-  return normalizeSystemMessages(out)
-}
-
-async function toOpenAIUserContent(blocks: MessageContentBlock[]): Promise<Array<Record<string, unknown>>> {
-  const parts: Array<Record<string, unknown>> = []
-  for (const block of blocks) {
-    if (block.type === 'text') {
-      if (block.text.length > 0) parts.push({ type: 'text', text: block.text })
-      continue
-    }
-    if (block.type === 'image') {
-      const loaded = await loadImageBlock(block)
-      if (loaded.url) {
-        parts.push({ type: 'image_url', image_url: { url: loaded.url } })
-      } else if (loaded.dataBase64 && loaded.mimeType) {
-        parts.push({ type: 'image_url', image_url: { url: `data:${loaded.mimeType};base64,${loaded.dataBase64}` } })
-      }
-      continue
-    }
-  }
-  return parts.length > 0 ? parts : [{ type: 'text', text: '' }]
-}
-
 export function supportsOpenAIImages(model: string): boolean {
   const normalized = model.toLowerCase()
   if (normalized.includes('gpt-3.5')) return false
@@ -366,42 +283,6 @@ export function localModelNameHintsVision(model: string): boolean {
   return /llava|bakllava|qwen[-_.]?vl|qwen2[-_.]?vl|qwen2\.5[-_.]?vl|minicpm-?v|llama-3\.2.*vision|mllama|cogvlm|internvl|moondream|pixtral|phi-?3[\.-]?vision|phi-?3\.5[\.-]?vision|smolvlm/.test(normalized)
 }
 
-function normalizeSystemMessages(messages: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
-  const systemContents: string[] = []
-  const nonSystem: Array<Record<string, unknown>> = []
-
-  for (const message of messages) {
-    if (message.role === 'system') {
-      if (typeof message.content === 'string' && message.content.length > 0) {
-        systemContents.push(message.content)
-      }
-      continue
-    }
-    nonSystem.push(message)
-  }
-
-  if (systemContents.length === 0) return nonSystem
-  return [
-    {
-      role: 'system',
-      content: systemContents.join('\n\n'),
-    },
-    ...nonSystem,
-  ]
-}
-
-function isTextBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'text' }> {
-  return block.type === 'text'
-}
-
-function isToolUseBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'tool_use' }> {
-  return block.type === 'tool_use'
-}
-
-function isToolResultBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'tool_result' }> {
-  return block.type === 'tool_result'
-}
-
 function parseToolArguments(inputJson: string): Record<string, unknown> {
   if (!inputJson.trim()) return {}
   const direct = tryParseJsonOnce(inputJson)

package/src/providers/openaiChatWire.ts

@@ -0,0 +1,124 @@
+import type { Message, MessageContentBlock } from './contracts.js'
+import { messageTextContent } from '../utils/messages.js'
+import { loadImageBlock } from '../utils/images.js'
+
+export async function toWireMessages(messages: Message[]): Promise<Array<Record<string, unknown>>> {
+  const out: Array<Record<string, unknown>> = []
+
+  for (const message of messages) {
+    if (typeof message.content === 'string') {
+      out.push({ role: message.role, content: message.content })
+      continue
+    }
+
+    if (message.role === 'user') {
+      const toolResults = message.content.filter(isToolResultBlock)
+      if (toolResults.length > 0) {
+        for (const block of toolResults) {
+          out.push({
+            role: 'tool',
+            tool_call_id: block.toolUseId,
+            content: block.content,
+          })
+        }
+        const nonToolBlocks = message.content.filter(block => block.type !== 'tool_result')
+        if (nonToolBlocks.length > 0) {
+          out.push({ role: 'user', content: await toOpenAIUserContent(nonToolBlocks) })
+        }
+        continue
+      }
+      out.push({ role: 'user', content: await toOpenAIUserContent(message.content) })
+      continue
+    }
+
+    if (message.role === 'assistant') {
+      const textParts = message.content.filter(isTextBlock).map(block => block.text)
+      const toolCalls = message.content.filter(isToolUseBlock).map(block => ({
+        id: block.id,
+        type: 'function',
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input),
+        },
+      }))
+      out.push({
+        role: 'assistant',
+        content: textParts.join(''),
+        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+      })
+      continue
+    }
+
+    const toolResults = message.content.filter(isToolResultBlock)
+    if (toolResults.length > 0) {
+      for (const block of toolResults) {
+        out.push({
+          role: 'tool',
+          tool_call_id: block.toolUseId,
+          content: block.content,
+        })
+      }
+      continue
+    }
+
+    out.push({ role: message.role, content: messageTextContent(message) })
+  }
+
+  return normalizeSystemMessages(out)
+}
+
+async function toOpenAIUserContent(blocks: MessageContentBlock[]): Promise<Array<Record<string, unknown>>> {
+  const parts: Array<Record<string, unknown>> = []
+  for (const block of blocks) {
+    if (block.type === 'text') {
+      if (block.text.length > 0) parts.push({ type: 'text', text: block.text })
+      continue
+    }
+    if (block.type === 'image') {
+      const loaded = await loadImageBlock(block)
+      if (loaded.url) {
+        parts.push({ type: 'image_url', image_url: { url: loaded.url } })
+      } else if (loaded.dataBase64 && loaded.mimeType) {
+        parts.push({ type: 'image_url', image_url: { url: `data:${loaded.mimeType};base64,${loaded.dataBase64}` } })
+      }
+      continue
+    }
+  }
+  return parts.length > 0 ? parts : [{ type: 'text', text: '' }]
+}
+
+function normalizeSystemMessages(messages: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
+  const systemContents: string[] = []
+  const nonSystem: Array<Record<string, unknown>> = []
+
+  for (const message of messages) {
+    if (message.role === 'system') {
+      if (typeof message.content === 'string' && message.content.length > 0) {
+        systemContents.push(message.content)
+      }
+      continue
+    }
+    nonSystem.push(message)
+  }
+
+  if (systemContents.length === 0) return nonSystem
+  return [
+    {
+      role: 'system',
+      content: systemContents.join('\n\n'),
+    },
+    ...nonSystem,
+  ]
+}
+
+function isTextBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'text' }> {
+  return block.type === 'text'
+}
+
+function isToolUseBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'tool_use' }> {
+  return block.type === 'tool_use'
+}
+
+function isToolResultBlock(block: MessageContentBlock): block is Extract<MessageContentBlock, { type: 'tool_result' }> {
+  return block.type === 'tool_result'
+}