@codori/client 0.0.2 → 0.0.4

package/server/api/codori/projects/[projectId]/attachments.post.ts

@@ -0,0 +1,53 @@
+import {
+  createError,
+  defineEventHandler,
+  getRequestHeader,
+  getRouterParam,
+  setResponseStatus
+} from 'h3'
+import { encodeProjectIdSegment } from '~~/shared/codori'
+import { proxyServerFetch } from '../../../../utils/server-proxy'
+
+export default defineEventHandler(async (event) => {
+  const projectId = getRouterParam(event, 'projectId')
+  if (!projectId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Missing project id.'
+    })
+  }
+
+  const contentType = getRequestHeader(event, 'content-type')
+  if (!contentType) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Missing content type.'
+    })
+  }
+
+  const response = await proxyServerFetch(
+    event,
+    `/api/projects/${encodeProjectIdSegment(projectId)}/attachments`,
+    {
+      method: 'POST',
+      headers: {
+        'content-type': contentType
+      },
+      body: event.node.req as unknown as BodyInit
+    }
+  )
+
+  const body = await response.json()
+  setResponseStatus(event, response.status)
+
+  if (!response.ok) {
+    const errorBody = body as { error?: { message?: string } }
+    throw createError({
+      statusCode: response.status,
+      statusMessage: errorBody.error?.message ?? 'Attachment upload failed.',
+      data: body
+    })
+  }
+
+  return body
+})

package/server/api/codori/service/update.get.ts

@@ -0,0 +1,7 @@
+import { defineEventHandler } from 'h3'
+import type { ServiceUpdateResponse } from '~~/shared/codori'
+import { proxyServerRequest } from '../../../utils/server-proxy'
+
+export default defineEventHandler(async (event) =>
+  await proxyServerRequest<ServiceUpdateResponse>(event, '/api/service/update')
+)

package/server/api/codori/service/update.post.ts

@@ -0,0 +1,9 @@
+import { defineEventHandler } from 'h3'
+import type { ServiceUpdateResponse } from '~~/shared/codori'
+import { proxyServerRequest } from '../../../utils/server-proxy'
+
+export default defineEventHandler(async (event) =>
+  await proxyServerRequest<ServiceUpdateResponse>(event, '/api/service/update', {
+    method: 'POST'
+  })
+)

package/server/utils/server-proxy.ts

@@ -23,3 +23,26 @@ export const proxyServerRequest = async <T>(
     body: options.body as BodyInit | Record<string, unknown> | undefined
   })
 }
+
+export const proxyServerFetch = async (
+  event: H3Event,
+  path: string,
+  options: {
+    method?: 'GET' | 'POST'
+    headers?: HeadersInit
+    body?: BodyInit | null
+  } = {}
+) => {
+  const baseURL = getServerBase(event)
+  const requestInit: RequestInit & { duplex?: 'half' } = {
+    method: options.method,
+    headers: options.headers,
+    body: options.body ?? null
+  }
+
+  if (options.body) {
+    requestInit.duplex = 'half'
+  }
+
+  return await fetch(`${baseURL}${path}`, requestInit)
+}

package/shared/chat-attachments.ts

@@ -0,0 +1,135 @@
+import type { CodexUserInput } from './codex-rpc'
+import { encodeProjectIdSegment } from './codori'
+import { resolveApiUrl, shouldUseServerProxy } from './network'
+
+export const MAX_ATTACHMENTS_PER_MESSAGE = 8
+export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024
+
+export type FileLike = {
+  name: string
+  size: number
+  type: string
+}
+
+export type AttachmentValidationIssue = {
+  code: 'tooMany' | 'unsupportedType' | 'tooLarge'
+  fileName: string
+  message: string
+}
+
+export type PersistedProjectAttachment = {
+  filename: string
+  mediaType: string | null
+  path: string
+}
+
+export type ProjectAttachmentUploadResponse = {
+  threadId: string
+  files: PersistedProjectAttachment[]
+}
+
+export const isSupportedAttachmentType = (mediaType: string) =>
+  mediaType.toLowerCase().startsWith('image/')
+
+export const validateAttachmentSelection = <T extends FileLike>(
+  files: T[],
+  existingCount: number
+) => {
+  const issues: AttachmentValidationIssue[] = []
+  const accepted: T[] = []
+
+  for (const file of files) {
+    if (existingCount + accepted.length >= MAX_ATTACHMENTS_PER_MESSAGE) {
+      issues.push({
+        code: 'tooMany',
+        fileName: file.name,
+        message: `You can attach up to ${MAX_ATTACHMENTS_PER_MESSAGE} images per message.`
+      })
+      continue
+    }
+
+    const mediaType = file.type || 'application/octet-stream'
+    if (!isSupportedAttachmentType(mediaType)) {
+      issues.push({
+        code: 'unsupportedType',
+        fileName: file.name,
+        message: 'Only image attachments are currently supported.'
+      })
+      continue
+    }
+
+    if (file.size > MAX_ATTACHMENT_BYTES) {
+      issues.push({
+        code: 'tooLarge',
+        fileName: file.name,
+        message: `Each image must be ${Math.floor(MAX_ATTACHMENT_BYTES / (1024 * 1024))} MB or smaller.`
+      })
+      continue
+    }
+
+    accepted.push(file)
+  }
+
+  return {
+    accepted,
+    issues
+  }
+}
+
+export const buildTurnStartInput = (
+  text: string,
+  attachments: Array<{ path: string }>
+): CodexUserInput[] => {
+  const input: CodexUserInput[] = []
+  const trimmedText = text.trim()
+
+  if (trimmedText) {
+    input.push({
+      type: 'text',
+      text: trimmedText,
+      text_elements: []
+    })
+  }
+
+  for (const attachment of attachments) {
+    input.push({
+      type: 'localImage',
+      path: attachment.path
+    })
+  }
+
+  return input
+}
+
+export const resolveAttachmentPreviewUrl = (input: {
+  projectId: string
+  path: string
+  configuredBase?: string | null
+}) => {
+  const query = new URLSearchParams({
+    path: input.path
+  })
+  const requestPath = `/projects/${encodeProjectIdSegment(input.projectId)}/attachments/file?${query.toString()}`
+
+  if (shouldUseServerProxy(input.configuredBase)) {
+    return `/api/codori${requestPath}`
+  }
+
+  return resolveApiUrl(
+    requestPath,
+    input.configuredBase
+  )
+}
+
+export const resolveAttachmentUploadUrl = (input: {
+  projectId: string
+  configuredBase?: string | null
+}) => {
+  const requestPath = `/projects/${encodeProjectIdSegment(input.projectId)}/attachments`
+
+  if (shouldUseServerProxy(input.configuredBase)) {
+    return `/api/codori${requestPath}`
+  }
+
+  return resolveApiUrl(requestPath, input.configuredBase)
+}

package/shared/chat-prompt-controls.ts

@@ -0,0 +1,339 @@
+export const FALLBACK_REASONING_EFFORTS = [
+  'none',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh'
+] as const
+
+export type ReasoningEffort = typeof FALLBACK_REASONING_EFFORTS[number]
+
+export type ModelOption = {
+  id: string
+  model: string
+  displayName: string
+  hidden: boolean
+  isDefault: boolean
+  defaultReasoningEffort: ReasoningEffort
+  supportedReasoningEfforts: ReasoningEffort[]
+}
+
+export type TokenUsageSnapshot = {
+  totalInputTokens: number
+  totalCachedInputTokens: number
+  totalOutputTokens: number
+  lastInputTokens: number
+  lastCachedInputTokens: number
+  lastOutputTokens: number
+  modelContextWindow: number | null
+}
+
+type ReasoningEffortOptionRecord = {
+  reasoningEffort?: unknown
+}
+
+type ModelRecord = {
+  id?: unknown
+  model?: unknown
+  displayName?: unknown
+  hidden?: unknown
+  isDefault?: unknown
+  defaultReasoningEffort?: unknown
+  supportedReasoningEfforts?: unknown
+}
+
+export const FALLBACK_MODELS: ModelOption[] = [
+  {
+    id: 'gpt-5.4',
+    model: 'gpt-5.4',
+    displayName: 'GPT-5.4',
+    hidden: false,
+    isDefault: true,
+    defaultReasoningEffort: 'medium',
+    supportedReasoningEfforts: [...FALLBACK_REASONING_EFFORTS]
+  },
+  {
+    id: 'gpt-5.4-mini',
+    model: 'gpt-5.4-mini',
+    displayName: 'GPT-5.4 Mini',
+    hidden: false,
+    isDefault: false,
+    defaultReasoningEffort: 'medium',
+    supportedReasoningEfforts: [...FALLBACK_REASONING_EFFORTS]
+  },
+  {
+    id: 'gpt-5.3-codex',
+    model: 'gpt-5.3-codex',
+    displayName: 'GPT-5.3 Codex',
+    hidden: false,
+    isDefault: false,
+    defaultReasoningEffort: 'medium',
+    supportedReasoningEfforts: [...FALLBACK_REASONING_EFFORTS]
+  }
+]
+
+const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+const isReasoningEffort = (value: unknown): value is ReasoningEffort =>
+  typeof value === 'string' && FALLBACK_REASONING_EFFORTS.includes(value as ReasoningEffort)
+
+const toFiniteNumber = (value: unknown) => {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value
+  }
+
+  if (typeof value === 'bigint') {
+    return Number(value)
+  }
+
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) {
+      return parsed
+    }
+  }
+
+  return null
+}
+
+const toReasoningEfforts = (value: unknown): ReasoningEffort[] => {
+  if (!Array.isArray(value)) {
+    return []
+  }
+
+  return value.flatMap((entry) => {
+    if (isReasoningEffort(entry)) {
+      return [entry]
+    }
+
+    const record = isObjectRecord(entry) ? entry as ReasoningEffortOptionRecord : null
+    return isReasoningEffort(record?.reasoningEffort) ? [record.reasoningEffort] : []
+  })
+}
+
+const normalizeModel = (value: unknown): ModelOption | null => {
+  const record = isObjectRecord(value) ? value as ModelRecord : null
+  if (!record || typeof record.model !== 'string') {
+    return null
+  }
+
+  const supportedReasoningEfforts = toReasoningEfforts(record.supportedReasoningEfforts)
+  const defaultReasoningEffort = isReasoningEffort(record.defaultReasoningEffort)
+    ? record.defaultReasoningEffort
+    : supportedReasoningEfforts[0] ?? 'medium'
+
+  return {
+    id: typeof record.id === 'string' ? record.id : record.model,
+    model: record.model,
+    displayName: typeof record.displayName === 'string' && record.displayName.trim()
+      ? record.displayName.trim()
+      : record.model,
+    hidden: Boolean(record.hidden),
+    isDefault: Boolean(record.isDefault),
+    defaultReasoningEffort,
+    supportedReasoningEfforts: supportedReasoningEfforts.length > 0
+      ? supportedReasoningEfforts
+      : [...FALLBACK_REASONING_EFFORTS]
+  }
+}
+
+export const normalizeModelList = (value: unknown): ModelOption[] => {
+  const data = isObjectRecord(value) && Array.isArray(value.data)
+    ? value.data
+    : Array.isArray(value)
+      ? value
+      : []
+
+  const models = data
+    .map(normalizeModel)
+    .filter((entry): entry is ModelOption => entry !== null)
+
+  return models.length > 0 ? models : FALLBACK_MODELS
+}
+
+export const ensureModelOption = (
+  models: ModelOption[],
+  model: string | null | undefined,
+  effort?: ReasoningEffort | null
+) => {
+  if (!model || models.some(entry => entry.model === model)) {
+    return models
+  }
+
+  return [{
+    id: model,
+    model,
+    displayName: model,
+    hidden: false,
+    isDefault: false,
+    defaultReasoningEffort: effort ?? 'medium',
+    supportedReasoningEfforts: [...FALLBACK_REASONING_EFFORTS]
+  }, ...models]
+}
+
+export const visibleModelOptions = (models: ModelOption[]) => {
+  const visible = models.filter(model => !model.hidden)
+  return visible.length > 0 ? visible : FALLBACK_MODELS
+}
+
+export const resolveSelectedModel = (
+  models: ModelOption[],
+  preferredModel?: string | null
+) => {
+  if (preferredModel && models.some(model => model.model === preferredModel)) {
+    return preferredModel
+  }
+
+  const defaultModel = models.find(model => model.isDefault)?.model
+  return defaultModel ?? models[0]?.model ?? FALLBACK_MODELS[0]!.model
+}
+
+export const resolveEffortOptions = (
+  models: ModelOption[],
+  model: string | null | undefined
+) => {
+  const selectedModel = models.find(entry => entry.model === model)
+  return selectedModel?.supportedReasoningEfforts.length
+    ? selectedModel.supportedReasoningEfforts
+    : [...FALLBACK_REASONING_EFFORTS]
+}
+
+export const resolveSelectedEffort = (
+  models: ModelOption[],
+  model: string | null | undefined,
+  preferredEffort?: ReasoningEffort | null
+) => {
+  const effortOptions = resolveEffortOptions(models, model)
+  if (preferredEffort && effortOptions.includes(preferredEffort)) {
+    return preferredEffort
+  }
+
+  const selectedModel = models.find(entry => entry.model === model)
+  if (selectedModel && effortOptions.includes(selectedModel.defaultReasoningEffort)) {
+    return selectedModel.defaultReasoningEffort
+  }
+
+  return effortOptions[0] ?? 'medium'
+}
+
+export const coercePromptSelection = (
+  models: ModelOption[],
+  preferredModel?: string | null,
+  preferredEffort?: ReasoningEffort | null
+) => {
+  const nextModel = resolveSelectedModel(models, preferredModel)
+  return {
+    model: nextModel,
+    effort: resolveSelectedEffort(models, nextModel, preferredEffort)
+  }
+}
+
+export const normalizeConfigDefaults = (value: unknown) => {
+  const config = isObjectRecord(value) && isObjectRecord(value.config)
+    ? value.config
+    : null
+
+  return {
+    model: typeof config?.model === 'string' ? config.model : null,
+    effort: isReasoningEffort(config?.model_reasoning_effort) ? config.model_reasoning_effort : null,
+    contextWindow: toFiniteNumber(config?.model_context_window)
+  }
+}
+
+export const normalizeThreadTokenUsage = (value: unknown): TokenUsageSnapshot | null => {
+  const params = isObjectRecord(value) ? value : null
+  const tokenUsage = isObjectRecord(params?.tokenUsage) ? params.tokenUsage : null
+  if (!tokenUsage) {
+    return null
+  }
+
+  const total = isObjectRecord(tokenUsage.total) ? tokenUsage.total : {}
+  const last = isObjectRecord(tokenUsage.last) ? tokenUsage.last : {}
+
+  return {
+    totalInputTokens: toFiniteNumber(total.inputTokens) ?? 0,
+    totalCachedInputTokens: toFiniteNumber(total.cachedInputTokens) ?? 0,
+    totalOutputTokens: toFiniteNumber(total.outputTokens) ?? 0,
+    lastInputTokens: toFiniteNumber(last.inputTokens) ?? 0,
+    lastCachedInputTokens: toFiniteNumber(last.cachedInputTokens) ?? 0,
+    lastOutputTokens: toFiniteNumber(last.outputTokens) ?? 0,
+    modelContextWindow: toFiniteNumber(tokenUsage.modelContextWindow)
+  }
+}
+
+export const buildTurnOverrides = (
+  model: string | null | undefined,
+  effort: ReasoningEffort | null | undefined
+) => {
+  const overrides: {
+    model?: string
+    effort?: ReasoningEffort
+  } = {}
+
+  if (model) {
+    overrides.model = model
+  }
+
+  if (effort) {
+    overrides.effort = effort
+  }
+
+  return overrides
+}
+
+export const formatReasoningEffortLabel = (value: ReasoningEffort) => {
+  switch (value) {
+    case 'xhigh':
+      return 'Very high'
+    case 'none':
+      return 'None'
+    default:
+      return value.charAt(0).toUpperCase() + value.slice(1)
+  }
+}
+
+export const formatCompactTokenCount = (value: number) => {
+  if (value < 1000) {
+    return String(value)
+  }
+
+  const short = value / 1000
+  const rounded = short >= 10 ? short.toFixed(0) : short.toFixed(1)
+  return `${rounded.replace(/\\.0$/, '')}k`
+}
+
+export const resolveContextWindowState = (
+  tokenUsage: TokenUsageSnapshot | null,
+  fallbackContextWindow: number | null,
+  usageKnown = true
+) => {
+  const contextWindow = tokenUsage?.modelContextWindow ?? fallbackContextWindow
+  const usedTokens = tokenUsage
+    ? tokenUsage.totalInputTokens + tokenUsage.totalOutputTokens
+    : usageKnown
+      ? 0
+      : null
+
+  if (!contextWindow || usedTokens == null) {
+    return {
+      contextWindow,
+      usedTokens,
+      remainingTokens: null,
+      usedPercent: null,
+      remainingPercent: null
+    }
+  }
+
+  const cappedUsedTokens = Math.max(0, Math.min(contextWindow, usedTokens))
+  const usedPercent = Math.max(0, Math.min(100, (cappedUsedTokens / contextWindow) * 100))
+
+  return {
+    contextWindow,
+    usedTokens: cappedUsedTokens,
+    remainingTokens: Math.max(0, contextWindow - cappedUsedTokens),
+    usedPercent,
+    remainingPercent: Math.max(0, 100 - usedPercent)
+  }
+}

package/shared/codex-chat.ts

@@ -2,6 +2,7 @@ import type { CodexThread, CodexThreadItem, CodexUserInput } from './codex-rpc'
 
 export const EVENT_PART = 'data-thread-event' as const
 export const ITEM_PART = 'data-thread-item' as const
+export const THINKING_PLACEHOLDER_MESSAGE_ID = 'assistant-thinking-placeholder'
 
 export type ThreadEventData =
   | {
@@ -100,6 +101,16 @@ export type ChatPart =
       text: string
       state?: 'done' | 'streaming'
     }
+  | {
+      type: 'attachment'
+      attachment: {
+        kind: 'image'
+        name: string
+        mediaType: string
+        url?: string | null
+        localPath?: string | null
+      }
+    }
   | {
       type: 'reasoning'
       summary: string[]
@@ -125,27 +136,39 @@ export type ChatMessage = {
 export const isSubagentActiveStatus = (status: SubagentAgentStatus) =>
   status === null || status === 'pendingInit' || status === 'running'
 
-const formatUserInput = (input: CodexUserInput) => {
+const streamingState = (pending?: boolean) => pending ? 'streaming' : 'done'
+
+const userInputToParts = (input: CodexUserInput): ChatPart[] => {
   if (input.type === 'text') {
-    return input.text
+    if (!input.text.trim()) {
+      return []
+    }
+
+    return [{
+      type: 'text',
+      text: input.text,
+      state: 'done'
+    }]
   }
 
-  return `[local image] ${input.path}`
+  return [{
+    type: 'attachment',
+    attachment: {
+      kind: 'image',
+      name: input.path.split(/[\\/]/).pop() || 'image',
+      mediaType: 'image/*',
+      localPath: input.path
+    }
+  }]
 }
 
-const streamingState = (pending?: boolean) => pending ? 'streaming' : 'done'
-
 export const itemToMessages = (item: CodexThreadItem): ChatMessage[] => {
   switch (item.type) {
     case 'userMessage':
       return [{
         id: item.id,
         role: 'user',
-        parts: [{
-          type: 'text',
-          text: item.content.map(formatUserInput).join('\n').trim(),
-          state: 'done'
-        }]
+        parts: item.content.flatMap(userInputToParts)
       }]
     case 'agentMessage':
       return [{
@@ -314,11 +337,13 @@ const normalizeParts = (message: ChatMessage): ChatPart[] =>
     return part
   })
 
+const normalizeMessage = (message: ChatMessage): ChatMessage => ({
+  ...message,
+  parts: normalizeParts(message)
+})
+
 export const upsertStreamingMessage = (messages: ChatMessage[], nextMessage: ChatMessage) => {
-  const normalizedMessage = {
-    ...nextMessage,
-    parts: normalizeParts(nextMessage)
-  }
+  const normalizedMessage = normalizeMessage(nextMessage)
   const nextMessages = messages.slice()
   const existingIndex = nextMessages.findIndex(message => message.id === normalizedMessage.id)
 
@@ -338,3 +363,43 @@ export const upsertStreamingMessage = (messages: ChatMessage[], nextMessage: Cha
 
   return nextMessages
 }
+
+export const replaceStreamingMessage = (messages: ChatMessage[], nextMessage: ChatMessage) => {
+  const normalizedMessage = normalizeMessage(nextMessage)
+  const nextMessages = messages.slice()
+  const existingIndex = nextMessages.findIndex(message => message.id === normalizedMessage.id)
+
+  if (existingIndex === -1) {
+    nextMessages.push(normalizedMessage)
+    return nextMessages
+  }
+
+  nextMessages.splice(existingIndex, 1, normalizedMessage)
+  return nextMessages
+}
+
+export const buildThinkingPlaceholderMessage = (): ChatMessage => ({
+  id: THINKING_PLACEHOLDER_MESSAGE_ID,
+  role: 'assistant',
+  pending: true,
+  parts: [{
+    type: 'reasoning',
+    summary: ['Thinking...'],
+    content: [],
+    state: 'streaming'
+  }]
+})
+
+export const showThinkingPlaceholder = (messages: ChatMessage[]) =>
+  upsertStreamingMessage(messages, buildThinkingPlaceholderMessage())
+
+export const hideThinkingPlaceholder = (messages: ChatMessage[]) => {
+  const index = messages.findIndex(message => message.id === THINKING_PLACEHOLDER_MESSAGE_ID)
+  if (index === -1) {
+    return messages
+  }
+
+  const nextMessages = messages.slice()
+  nextMessages.splice(index, 1)
+  return nextMessages
+}