diff --git a/console/web/src/components/chat/Composer.stories.tsx b/console/web/src/components/chat/Composer.stories.tsx
index cf3f784a7..386755a45 100644
--- a/console/web/src/components/chat/Composer.stories.tsx
+++ b/console/web/src/components/chat/Composer.stories.tsx
@@ -3,7 +3,13 @@ import { $createParagraphNode, $createTextNode, $getRoot } from 'lexical'
 import { useState } from 'react'
 import { fn } from 'storybook/test'
 import { STATIC_FUNCTIONS } from '@/lib/functions'
-import type { Attachment, Mode, ModelId, ModelOption } from '@/types/chat'
+import type {
+  Attachment,
+  Mode,
+  ModelId,
+  ModelOption,
+  ThinkingLevel,
+} from '@/types/chat'
 
 const STORY_MODEL_OPTIONS: ModelOption[] = [
   {
@@ -11,6 +17,15 @@ const STORY_MODEL_OPTIONS: ModelOption[] = [
     label: 'gpt-5',
     contextWindow: 400_000,
     supportsThinking: true,
+    reasoningEfforts: [
+      { effort: 'none', description: 'fastest responses without reasoning' },
+      { effort: 'minimal', description: 'minimal reasoning overhead' },
+      { effort: 'low', description: 'quick reasoning for routine tasks' },
+      { effort: 'medium', description: 'balanced reasoning and latency' },
+      { effort: 'high', description: 'deeper reasoning for complex tasks' },
+      { effort: 'xhigh', description: 'extended reasoning for hard tasks' },
+      { effort: 'ultra', description: 'maximum model-native reasoning' },
+    ],
   },
   {
     id: 'anthropic::claude-opus-4-7',
@@ -24,6 +39,12 @@ const STORY_MODEL_OPTIONS: ModelOption[] = [
     contextWindow: 400_000,
     supportsThinking: true,
   },
+  {
+    id: 'openai::gpt-4.1',
+    label: 'gpt-4.1',
+    contextWindow: 1_000_000,
+    supportsThinking: false,
+  },
 ]
 
 import { Composer } from './Composer'
@@ -73,6 +94,7 @@ function ComposerHarness({
 }) {
   const [mode, setMode] = useState<Mode>(initialMode)
   const [model, setModel] = useState<ModelId>(initialModel)
+  const [thinkingLevel, setThinkingLevel] = useState<ThinkingLevel>('default')
   return (
     <Composer
       mode={mode}
@@ -80,8 +102,8 @@ function ComposerHarness({
       modelOptions={STORY_MODEL_OPTIONS}
       functionEntries={STATIC_FUNCTIONS}
       permissionMode="manual"
-      thinkingLevel="off"
-      onThinkingLevelChange={fn()}
+      thinkingLevel={thinkingLevel}
+      onThinkingLevelChange={setThinkingLevel}
       onModeChange={setMode}
       onModelChange={setModel}
       onPermissionModeChange={fn()}
diff --git a/console/web/src/components/chat/ModelPicker.tsx b/console/web/src/components/chat/ModelPicker.tsx
index 471e1413b..3ecc065e1 100644
--- a/console/web/src/components/chat/ModelPicker.tsx
+++ b/console/web/src/components/chat/ModelPicker.tsx
@@ -1,18 +1,20 @@
-import * as SelectPrimitive from '@radix-ui/react-select'
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu'
 import {
   Check,
   ChevronDown,
+  ChevronRight,
   ChevronUp,
   RefreshCw,
   Settings,
 } from 'lucide-react'
-import { useMemo, useState } from 'react'
+import { useEffect, useMemo, useRef, useState } from 'react'
 import { useConversationsCtxOptional } from '@/lib/conversations-context'
 import { cn } from '@/lib/utils'
 import {
   CATALOG_MODEL_KEY_SEP,
   type ModelId,
   type ModelOption,
+  type ReasoningEffortOption,
   THINKING_LEVELS,
   type ThinkingLevel,
 } from '@/types/chat'
@@ -22,6 +24,11 @@ import {
 // per-provider dialog was retired in favour of the schema-driven form).
 const HARNESS_CONFIG_HASH = '#/workers/configuration/llm-router'
 
+const DEFAULT_EFFORT: ReasoningEffortOption = {
+  effort: 'default',
+  description: 'use the model default',
+}
+
 interface ModelPickerProps {
   value: ModelId | null
   options: ModelOption[]
@@ -51,19 +58,29 @@ function groupByProvider(options: ModelOption[]): ModelGroup[] {
     .map(([label, opts]) => ({ label, options: opts }))
 }
 
-function formatThinkingLevel(level: ThinkingLevel): string {
-  return level === 'off' ? 'thinking off' : `thinking ${level}`
+function providerForModel(modelId: ModelId | undefined): string | null {
+  return modelId?.split(CATALOG_MODEL_KEY_SEP)[0] || null
 }
 
-function triggerLabel(
+function effortOptionsFor(
   model: ModelOption | undefined,
-  thinkingLevel: ThinkingLevel,
-): string | undefined {
-  if (!model) return undefined
-  if (model.supportsThinking && thinkingLevel !== 'off') {
-    return `${model.label} · ${formatThinkingLevel(thinkingLevel)}`
+): ReasoningEffortOption[] {
+  if (!model) return []
+  if (model.reasoningEfforts && model.reasoningEfforts.length > 0) {
+    return [
+      DEFAULT_EFFORT,
+      ...model.reasoningEfforts.filter((option) => option.effort !== 'default'),
+    ]
   }
-  return model.label
+  if (!model.supportsThinking) return []
+  return THINKING_LEVELS.map((effort) => ({ effort }))
+}
+
+function effortSupported(
+  options: ReasoningEffortOption[],
+  effort: ThinkingLevel,
+): boolean {
+  return options.some((option) => option.effort === effort)
 }
 
 export function ModelPicker({
@@ -78,11 +95,19 @@ export function ModelPicker({
 }: ModelPickerProps) {
   const ctx = useConversationsCtxOptional()
   const [open, setOpen] = useState(false)
-  const [expandedModelId, setExpandedModelId] = useState<ModelId | null>(null)
+  const [expandedProvider, setExpandedProvider] = useState<string | null>(null)
+  const [effortFocusRequest, setEffortFocusRequest] = useState(0)
+  const effortByModel = useRef(new Map<ModelId, ThinkingLevel>())
+  const modelItemRefs = useRef(new Map<ModelId, HTMLElement>())
+  const effortItemRefs = useRef(new Map<ThinkingLevel, HTMLElement>())
+  const pendingEffortFocus = useRef<{
+    model: ModelId
+    effort: ThinkingLevel
+  } | null>(null)
 
   const presentIds = ctx?.presentProviders.map((p) => p.id) ?? []
   const presentSet = new Set<string>(presentIds)
-  // Providers the router declares but whose worker is not loaded — their
+  // Providers the router declares but whose worker is not loaded: their
   // catalog models would only fail with `provider_unavailable` at dispatch.
   const unavailableSet = new Set(
     (ctx?.presentProviders ?? [])
@@ -91,19 +116,20 @@ export function ModelPicker({
   )
 
   const optionsById = useMemo(
-    () => new Map(options.map((o) => [o.id, o])),
+    () => new Map(options.map((option) => [option.id, option])),
     [options],
   )
 
   const pickerOptions = options
   const safeValue =
-    value != null && pickerOptions.some((o) => o.id === value)
+    value != null && pickerOptions.some((option) => option.id === value)
       ? value
       : undefined
   const selected = safeValue ? optionsById.get(safeValue) : undefined
+  const selectedEfforts = useMemo(() => effortOptionsFor(selected), [selected])
 
   const modelGroups = groupByProvider(pickerOptions)
-  const grouped = new Set(modelGroups.map((g) => g.label))
+  const grouped = new Set(modelGroups.map((group) => group.label))
   const emptyGroups: ModelGroup[] = presentIds
     .filter((id) => !grouped.has(id))
     .map((id) => ({ label: id, options: [] }))
@@ -113,72 +139,151 @@ export function ModelPicker({
 
   const pickerDisabled = disabled || loading || groups.length === 0
 
-  function handleThinkingPick(modelId: ModelId, level: ThinkingLevel) {
-    onThinkingLevelChange(level)
-    if (safeValue !== modelId) onChange(modelId)
+  useEffect(() => {
+    if (pickerDisabled && open) setOpen(false)
+  }, [pickerDisabled, open])
+
+  useEffect(() => {
+    if (!safeValue) return
+    if (effortSupported(selectedEfforts, thinkingLevel)) {
+      effortByModel.current.set(safeValue, thinkingLevel)
+      return
+    }
+    if (thinkingLevel !== 'default') onThinkingLevelChange('default')
+    effortByModel.current.set(safeValue, 'default')
+  }, [safeValue, selectedEfforts, thinkingLevel, onThinkingLevelChange])
+
+  useEffect(() => {
+    if (
+      !open ||
+      !safeValue ||
+      expandedProvider !== providerForModel(safeValue)
+    ) {
+      return
+    }
+    const frame = window.requestAnimationFrame(() => {
+      modelItemRefs.current.get(safeValue)?.focus()
+    })
+    return () => window.cancelAnimationFrame(frame)
+  }, [expandedProvider, open, safeValue])
+
+  useEffect(() => {
+    if (effortFocusRequest === 0) return
+    const pending = pendingEffortFocus.current
+    if (!open || !pending || pending.model !== safeValue) return
+    const target =
+      effortItemRefs.current.get(pending.effort) ??
+      effortItemRefs.current.get('default')
+    if (!target) return
+    pendingEffortFocus.current = null
+    target.focus()
+  }, [effortFocusRequest, open, safeValue])
+
+  function handleModelChange(next: string) {
+    const nextModel = optionsById.get(next)
+    const nextEfforts = effortOptionsFor(nextModel)
+    const remembered = effortByModel.current.get(next) ?? 'default'
+    const nextEffort = effortSupported(nextEfforts, remembered)
+      ? remembered
+      : 'default'
+    onChange(next)
+    if (nextEffort !== thinkingLevel) onThinkingLevelChange(nextEffort)
+    return { nextEfforts, nextEffort }
+  }
+
+  function handleEffortChange(next: ThinkingLevel) {
+    if (safeValue) effortByModel.current.set(safeValue, next)
+    onThinkingLevelChange(next)
+  }
+
+  function handleOpenChange(nextOpen: boolean) {
+    if (nextOpen) {
+      setExpandedProvider(
+        providerForModel(safeValue) ?? groups[0]?.label ?? null,
+      )
+    }
+    setOpen(nextOpen)
   }
 
   return (
-    <span className="inline-flex items-center gap-1">
-      <SelectPrimitive.Root
-        value={safeValue ?? ''}
-        open={open}
-        onOpenChange={(next) => {
-          setOpen(next)
-          if (!next) setExpandedModelId(null)
-        }}
-        onValueChange={(next) => {
-          onChange(next as ModelId)
-          setExpandedModelId(null)
-        }}
-        disabled={pickerDisabled}
-      >
-        <SelectPrimitive.Trigger
-          aria-label={loading ? 'model (loading catalog)' : 'model'}
-          aria-busy={loading || undefined}
-          className={cn(
-            'inline-flex items-center justify-between gap-x-2 border border-rule bg-bg px-3 h-9 text-ink font-mono text-[13px] lowercase focus:outline-none focus:border-ink data-[state=open]:border-ink transition-colors max-w-full min-w-0 data-[placeholder]:text-ink-faint',
-            pickerDisabled && 'opacity-40 pointer-events-none',
-            className,
-          )}
-        >
-          <span className="min-w-0 flex-1 truncate text-left">
-            <SelectPrimitive.Value
-              placeholder={loading ? 'loading…' : 'no models'}
-            >
-              {triggerLabel(selected, thinkingLevel)}
-            </SelectPrimitive.Value>
-          </span>
-          <SelectPrimitive.Icon asChild>
+    <span className="inline-flex min-w-0 items-center gap-1">
+      <DropdownMenuPrimitive.Root open={open} onOpenChange={handleOpenChange}>
+        <DropdownMenuPrimitive.Trigger asChild disabled={pickerDisabled}>
+          <button
+            type="button"
+            aria-label={
+              loading
+                ? 'model (loading catalog)'
+                : selected
+                  ? `model: ${selected.label}, reasoning effort: ${thinkingLevel}`
+                  : 'model'
+            }
+            aria-busy={loading || undefined}
+            className={cn(
+              'inline-flex h-9 min-w-0 max-w-full items-center justify-between gap-x-2 border border-rule bg-bg px-3 font-mono text-[13px] lowercase text-ink transition-colors focus:border-ink focus:outline-none data-[state=open]:border-ink',
+              pickerDisabled && 'pointer-events-none opacity-40',
+              className,
+            )}
+          >
+            <span className="flex min-w-0 flex-1 items-baseline gap-1.5 truncate text-left">
+              <span className={cn('truncate', !selected && 'text-ink-faint')}>
+                {selected?.label ?? (loading ? 'loading…' : 'no models')}
+              </span>
+              {selectedEfforts.length > 1 && thinkingLevel !== 'default' ? (
+                <span className="shrink-0 text-[11px] text-ink-faint">
+                  · {thinkingLevel}
+                </span>
+              ) : null}
+            </span>
             {open ? (
               <ChevronUp size={12} aria-hidden />
             ) : (
               <ChevronDown size={12} aria-hidden />
             )}
-          </SelectPrimitive.Icon>
-        </SelectPrimitive.Trigger>
+          </button>
+        </DropdownMenuPrimitive.Trigger>
 
-        <SelectPrimitive.Portal>
-          <SelectPrimitive.Content
-            position="popper"
+        <DropdownMenuPrimitive.Portal>
+          <DropdownMenuPrimitive.Content
             sideOffset={4}
-            className={cn(
-              'z-50 min-w-[var(--radix-select-trigger-width)] overflow-hidden border border-rule bg-bg text-ink font-mono text-[13px] lowercase shadow-lg',
-              'data-[state=open]:animate-in data-[state=closed]:animate-out',
-              'data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0',
-            )}
+            align="start"
+            className="z-50 w-[min(480px,calc(100vw-24px))] overflow-hidden border border-rule bg-bg font-mono text-[13px] lowercase text-ink"
           >
-            <SelectPrimitive.Viewport className="p-1 max-h-[60vh]">
-              {groups.map((g) => {
-                const unavailable = unavailableSet.has(g.label)
-                const unconfigured = !unavailable && g.options.length === 0
+            <DropdownMenuPrimitive.RadioGroup
+              value={safeValue ?? ''}
+              className="max-h-[50vh] overflow-y-auto p-1"
+            >
+              {groups.map((group) => {
+                const unavailable = unavailableSet.has(group.label)
+                const unconfigured = !unavailable && group.options.length === 0
+                const expanded = expandedProvider === group.label
                 return (
-                  <SelectPrimitive.Group key={g.label}>
-                    <div className="flex items-center justify-between gap-2 pr-2 pt-2 pb-1">
-                      <span className="flex min-w-0 items-baseline gap-1.5">
-                        <SelectPrimitive.Label className="px-3 text-[11px] uppercase tracking-[0.12em] text-ink-faint">
-                          {g.label}
-                        </SelectPrimitive.Label>
+                  <DropdownMenuPrimitive.Group key={group.label}>
+                    <div className="flex items-center gap-1 pr-2">
+                      <DropdownMenuPrimitive.Item
+                        aria-expanded={expanded}
+                        onSelect={(event) => {
+                          event.preventDefault()
+                          setExpandedProvider(expanded ? null : group.label)
+                        }}
+                        className="flex min-w-0 flex-1 cursor-pointer select-none items-center gap-1.5 px-2 py-2 text-ink-faint outline-none data-[highlighted]:bg-panel data-[highlighted]:text-ink"
+                      >
+                        {expanded ? (
+                          <ChevronDown
+                            size={12}
+                            className="shrink-0"
+                            aria-hidden
+                          />
+                        ) : (
+                          <ChevronRight
+                            size={12}
+                            className="shrink-0"
+                            aria-hidden
+                          />
+                        )}
+                        <span className="truncate text-[11px] uppercase tracking-[0.12em]">
+                          {group.label}
+                        </span>
                         {unavailable ? (
                           <span className="text-[10px] lowercase tracking-normal text-ink-ghost">
                             not loaded
@@ -188,122 +293,118 @@ export function ModelPicker({
                             not configured
                           </span>
                         ) : null}
-                      </span>
-                      {presentSet.has(g.label) ? (
+                      </DropdownMenuPrimitive.Item>
+                      {presentSet.has(group.label) ? (
                         <button
                           type="button"
-                          aria-label={`configure ${g.label}`}
-                          title={`configure ${g.label} in harness configuration`}
-                          onPointerDown={(e) => e.stopPropagation()}
-                          onClick={(e) => {
-                            e.preventDefault()
-                            e.stopPropagation()
+                          aria-label={`configure ${group.label}`}
+                          title={`configure ${group.label} in harness configuration`}
+                          onPointerDown={(event) => event.stopPropagation()}
+                          onClick={(event) => {
+                            event.preventDefault()
+                            event.stopPropagation()
                             window.location.hash = HARNESS_CONFIG_HASH
                           }}
-                          className="text-ink-faint hover:text-ink transition-colors p-0.5 -mr-0.5"
+                          className="-mr-0.5 p-0.5 text-ink-faint transition-colors hover:text-ink"
                         >
                           <Settings size={12} />
                         </button>
                       ) : null}
                     </div>
-                    {g.options.map((opt) => {
-                      const expanded = expandedModelId === opt.id
-                      // Gates the edit button AND the level panel: picking a
-                      // level calls onChange(opt.id), which must not select a
-                      // model whose row is disabled as unavailable.
-                      const showThinking =
-                        opt.supportsThinking === true && !unavailable
-                      return (
-                        <div key={opt.id}>
-                          <div className="group/model relative flex items-center">
-                            <SelectPrimitive.Item
-                              value={opt.id}
-                              disabled={unavailable}
-                              className={cn(
-                                'relative flex flex-1 min-w-0 items-center pl-7 pr-12 py-1.5 cursor-pointer outline-none select-none',
-                                'data-[highlighted]:bg-rule data-[highlighted]:text-ink',
-                                'data-[state=checked]:text-ink',
-                                'data-[disabled]:opacity-40 data-[disabled]:cursor-default',
-                              )}
-                            >
-                              <SelectPrimitive.ItemIndicator className="absolute left-2 top-1/2 -translate-y-1/2 text-ink">
-                                <Check size={12} aria-hidden />
-                              </SelectPrimitive.ItemIndicator>
-                              <SelectPrimitive.ItemText className="truncate">
-                                {opt.label}
-                              </SelectPrimitive.ItemText>
-                            </SelectPrimitive.Item>
-                            {showThinking ? (
-                              <button
-                                type="button"
-                                aria-label={`edit thinking for ${opt.label}`}
-                                aria-expanded={expanded}
-                                onPointerDown={(e) => e.stopPropagation()}
-                                onClick={(e) => {
-                                  e.preventDefault()
-                                  e.stopPropagation()
-                                  setExpandedModelId((current) =>
-                                    current === opt.id ? null : opt.id,
-                                  )
-                                }}
-                                className={cn(
-                                  'absolute right-2 top-1/2 -translate-y-1/2 px-1.5 py-0.5 text-[11px] text-ink-ghost transition-opacity',
-                                  'opacity-0 group-hover/model:opacity-100 focus-visible:opacity-100',
-                                  expanded && 'opacity-100 text-ink',
-                                )}
-                              >
-                                edit
-                              </button>
-                            ) : null}
-                          </div>
-                          {expanded && showThinking ? (
-                            <div className="ml-7 border-l border-rule-2 pl-2 pb-1">
-                              {THINKING_LEVELS.map((level) => {
-                                const active =
-                                  safeValue === opt.id &&
-                                  thinkingLevel === level
-                                return (
-                                  <button
-                                    key={level}
-                                    type="button"
-                                    onPointerDown={(e) => e.stopPropagation()}
-                                    onClick={(e) => {
-                                      e.preventDefault()
-                                      e.stopPropagation()
-                                      handleThinkingPick(opt.id, level)
-                                    }}
-                                    className={cn(
-                                      'flex w-full items-center gap-2 px-2 py-1 text-left text-[12px] transition-colors',
-                                      active
-                                        ? 'text-ink'
-                                        : 'text-ink-faint hover:text-ink hover:bg-rule',
-                                    )}
-                                  >
-                                    <span
-                                      aria-hidden
-                                      className={cn(
-                                        'w-3 text-center',
-                                        active ? 'opacity-100' : 'opacity-0',
-                                      )}
-                                    >
-                                      <Check size={12} aria-hidden />
-                                    </span>
-                                    {formatThinkingLevel(level)}
-                                  </button>
-                                )
-                              })}
-                            </div>
-                          ) : null}
-                        </div>
-                      )
-                    })}
-                  </SelectPrimitive.Group>
+                    {expanded
+                      ? group.options.map((option) => (
+                          <DropdownMenuPrimitive.RadioItem
+                            key={option.id}
+                            ref={(node) => {
+                              if (node) {
+                                modelItemRefs.current.set(option.id, node)
+                              } else {
+                                modelItemRefs.current.delete(option.id)
+                              }
+                            }}
+                            value={option.id}
+                            disabled={unavailable}
+                            onSelect={(event) => {
+                              event.preventDefault()
+                              const { nextEfforts, nextEffort } =
+                                handleModelChange(option.id)
+                              if (nextEfforts.length > 1) {
+                                pendingEffortFocus.current = {
+                                  model: option.id,
+                                  effort: nextEffort,
+                                }
+                                setEffortFocusRequest((request) => request + 1)
+                              }
+                            }}
+                            className={cn(
+                              'relative flex min-w-0 cursor-pointer select-none items-center py-1.5 pl-7 pr-3 outline-none',
+                              'data-[highlighted]:bg-panel data-[highlighted]:text-ink',
+                              'data-[state=checked]:text-ink',
+                              'data-[disabled]:cursor-default data-[disabled]:opacity-40',
+                            )}
+                          >
+                            <DropdownMenuPrimitive.ItemIndicator className="absolute left-2 top-1/2 -translate-y-1/2 text-ink">
+                              <Check size={12} aria-hidden />
+                            </DropdownMenuPrimitive.ItemIndicator>
+                            <span className="truncate">{option.label}</span>
+                          </DropdownMenuPrimitive.RadioItem>
+                        ))
+                      : null}
+                  </DropdownMenuPrimitive.Group>
                 )
               })}
-            </SelectPrimitive.Viewport>
-          </SelectPrimitive.Content>
-        </SelectPrimitive.Portal>
-      </SelectPrimitive.Root>
+            </DropdownMenuPrimitive.RadioGroup>
+
+            <div className="flex min-h-10 items-center gap-1 border-t border-rule bg-panel px-3 py-2">
+              <span className="shrink-0 text-[10px] uppercase tracking-[0.12em] text-ink-faint">
+                effort
+              </span>
+              {selectedEfforts.length > 1 ? (
+                <DropdownMenuPrimitive.RadioGroup
+                  value={thinkingLevel}
+                  className="flex min-w-0 items-center whitespace-nowrap"
+                >
+                  {selectedEfforts.map((option) => (
+                    <DropdownMenuPrimitive.RadioItem
+                      key={option.effort}
+                      value={option.effort}
+                      ref={(node) => {
+                        if (node) {
+                          effortItemRefs.current.set(option.effort, node)
+                        } else {
+                          effortItemRefs.current.delete(option.effort)
+                        }
+                      }}
+                      aria-label={option.effort}
+                      title={option.description}
+                      onSelect={() => {
+                        handleEffortChange(option.effort)
+                        setOpen(false)
+                      }}
+                      className={cn(
+                        'cursor-pointer select-none border px-1.5 py-1 text-[11px] outline-none transition-colors data-[highlighted]:bg-paper-2 data-[highlighted]:text-ink',
+                        'border-transparent text-ink-faint data-[state=checked]:border-ink data-[state=checked]:bg-ink data-[state=checked]:text-bg',
+                      )}
+                    >
+                      {option.effort}
+                    </DropdownMenuPrimitive.RadioItem>
+                  ))}
+                </DropdownMenuPrimitive.RadioGroup>
+              ) : (
+                <span
+                  role="status"
+                  aria-live="polite"
+                  className="truncate text-[11px] text-ink-faint"
+                >
+                  {selected
+                    ? 'this model uses its default effort'
+                    : 'select a model to see effort options'}
+                </span>
+              )}
+            </div>
+          </DropdownMenuPrimitive.Content>
+        </DropdownMenuPrimitive.Portal>
+      </DropdownMenuPrimitive.Root>
 
       {ctx ? (
         <button
@@ -314,7 +415,7 @@ export function ModelPicker({
           onClick={() => {
             void ctx.refreshModels()
           }}
-          className="text-ink-ghost hover:text-ink transition-colors p-1 disabled:opacity-50"
+          className="p-1 text-ink-ghost transition-colors hover:text-ink disabled:opacity-50"
         >
           <RefreshCw
             size={12}
diff --git a/console/web/src/components/permissions/PermissionModePicker.tsx b/console/web/src/components/permissions/PermissionModePicker.tsx
index 7b37dccbe..05feec859 100644
--- a/console/web/src/components/permissions/PermissionModePicker.tsx
+++ b/console/web/src/components/permissions/PermissionModePicker.tsx
@@ -1,5 +1,5 @@
 import { useState } from 'react'
-import { ModeToggle } from '@/components/ui/ModeToggle'
+import { Select } from '@/components/ui/Select'
 import type { PermissionMode } from '@/lib/backend/approval-settings'
 import { FullModeConfirmDialog } from './FullModeConfirmDialog'
 
@@ -13,10 +13,10 @@ interface PermissionModePickerProps {
 }
 
 /**
- * In-chat permission mode picker. Lives next to the composer; commits
- * each change directly to the backend through `onChange`. Selecting Full
- * gates on the shared confirmation dialog. Allowlist management lives
- * on the Configuration screen — keep this control narrow.
+ * In-chat permission mode picker. Lives next to the composer as one compact
+ * dropdown and commits each change directly to the backend through `onChange`.
+ * Selecting Full gates on the shared confirmation dialog. Allowlist
+ * management lives on the Configuration screen, keep this control narrow.
  */
 export function PermissionModePicker({
   value,
@@ -36,11 +36,12 @@ export function PermissionModePicker({
 
   return (
     <>
-      <ModeToggle<PermissionMode>
+      <Select<PermissionMode>
         value={value}
         onChange={handleSelect}
-        variant="radio"
-        aria-label="permission mode"
+        disabled={disabled}
+        aria-label="approval mode"
+        className="min-w-[92px]"
         options={[
           { value: 'manual', label: 'manual' },
           { value: 'auto', label: 'auto' },
diff --git a/console/web/src/hooks/use-model-picker-source.ts b/console/web/src/hooks/use-model-picker-source.ts
index 345178fa1..6f688e6e1 100644
--- a/console/web/src/hooks/use-model-picker-source.ts
+++ b/console/web/src/hooks/use-model-picker-source.ts
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { onHarnessConfigSaved } from '@/lib/harness-config-events'
 import {
   catalogRowsToModelOptions,
@@ -19,9 +19,9 @@ import type { ModelOption } from '@/types/chat'
  * shows present-but-unconfigured providers as gear groups). When the engine is
  * unreachable (catalog fetch throws) the list stays empty.
  *
- * `presentProviders` comes from `router::provider::list` so the picker can
- * surface providers that exist as workers but aren't configured yet.
- * `refresh()` re-reads both on demand (after a provider `refresh_models`).
+ * `presentProviders` is seeded by one `router::provider::list` read, then kept
+ * current by provider lifecycle events. Catalog refreshes never poll the
+ * provider list.
  *
  * `harnessAvailable` gates harness-owned RPCs until the worker is connected.
  */
@@ -39,6 +39,7 @@ export function useModelPickerSource(
   const [presentProviders, setPresentProviders] = useState<ProviderListEntry[]>(
     [],
   )
+  const providerEventVersion = useRef(0)
   const [catalogLoading, setCatalogLoading] = useState(
     backendId === 'real' && harnessAvailable,
   )
@@ -46,30 +47,20 @@ export function useModelPickerSource(
   const refresh = useCallback(async () => {
     if (backendId !== 'real') {
       setModelOptions([])
-      setPresentProviders([])
       setCatalogLoading(false)
       return
     }
     if (!harnessAvailable) {
       setModelOptions([])
-      setPresentProviders([])
       setCatalogLoading(false)
       return
     }
     setCatalogLoading(true)
     try {
-      // A provider-list failure shouldn't blank the model list, so it has its
-      // own fallback; a models::list throw signals an unreachable engine and
-      // leaves the option list empty.
-      const [rows, providers] = await Promise.all([
-        fetchModelsCatalog(),
-        fetchProviderList().catch(() => [] as ProviderListEntry[]),
-      ])
+      const rows = await fetchModelsCatalog()
       setModelOptions(catalogRowsToModelOptions(rows))
-      setPresentProviders(providers)
     } catch {
       setModelOptions([])
-      setPresentProviders([])
     } finally {
       setCatalogLoading(false)
     }
@@ -79,6 +70,31 @@ export function useModelPickerSource(
     void refresh()
   }, [refresh])
 
+  // One initial snapshot. Subsequent availability changes are applied from
+  // `router::provider::changed`, so model refreshes never re-read this list.
+  useEffect(() => {
+    if (backendId !== 'real' || !harnessAvailable) {
+      setPresentProviders([])
+      return
+    }
+    let cancelled = false
+    const snapshotVersion = providerEventVersion.current
+    void fetchProviderList()
+      .then((providers) => {
+        if (!cancelled && providerEventVersion.current === snapshotVersion) {
+          setPresentProviders(providers)
+        }
+      })
+      .catch(() => {
+        if (!cancelled && providerEventVersion.current === snapshotVersion) {
+          setPresentProviders([])
+        }
+      })
+    return () => {
+      cancelled = true
+    }
+  }, [backendId, harnessAvailable])
+
   // Live updates: re-pull the catalog when the harness signals a model change
   // (provider configured/cleared, refresh_models, CLI edits). The harness
   // coalesces bursts; the short trailing debounce here collapses any remaining
@@ -89,7 +105,7 @@ export function useModelPickerSource(
     const disposers: (() => void)[] = []
     let timer: ReturnType<typeof setTimeout> | null = null
 
-    const onChange = () => {
+    const onModelsChanged = () => {
       if (timer !== null) clearTimeout(timer)
       timer = setTimeout(() => {
         timer = null
@@ -97,18 +113,36 @@ export function useModelPickerSource(
       }, 150)
     }
 
-    // Catalog changes AND provider availability flips — a provider going
-    // down/up keeps its catalog models, so only provider::changed re-greys
-    // or re-enables its picker group without a manual refresh.
-    for (const subscribe of [subscribeModelChanges, subscribeProviderChanges]) {
-      void subscribe(onChange).then((d) => {
-        if (disposed) {
-          d()
-          return
+    void subscribeModelChanges(onModelsChanged).then((dispose) => {
+      if (disposed) dispose()
+      else disposers.push(dispose)
+    })
+
+    void subscribeProviderChanges(({ provider, op }) => {
+      providerEventVersion.current += 1
+      setPresentProviders((current) => {
+        const available = op !== 'unavailable'
+        const existing = current.find((entry) => entry.id === provider)
+        if (existing) {
+          if (existing.available === available) return current
+          return current.map((entry) =>
+            entry.id === provider ? { ...entry, available } : entry,
+          )
         }
-        disposers.push(d)
+        return [
+          ...current,
+          {
+            id: provider,
+            display_name: provider,
+            supports_model_listing: true,
+            available,
+          },
+        ]
       })
-    }
+    }).then((dispose) => {
+      if (disposed) dispose()
+      else disposers.push(dispose)
+    })
 
     return () => {
       disposed = true
diff --git a/console/web/src/lib/backend/harness-send.ts b/console/web/src/lib/backend/harness-send.ts
index 15ae8d450..f334fa0cb 100644
--- a/console/web/src/lib/backend/harness-send.ts
+++ b/console/web/src/lib/backend/harness-send.ts
@@ -46,6 +46,8 @@ export interface HarnessSendOptions {
   mode?: HarnessSendMode
   max_turns?: number
   thinking_level?: HarnessThinkingLevel
+  /** Provider-native options, namespaced by provider id. */
+  provider_options?: Record<string, unknown>
   output?: HarnessOutputContract
   functions?: HarnessFunctionPolicy
   /** Tracing passthrough (session_id / message_id propagate as baggage). */
diff --git a/console/web/src/lib/backend/real-metadata.test.ts b/console/web/src/lib/backend/real-metadata.test.ts
index 6c7692fe6..20a1d27d9 100644
--- a/console/web/src/lib/backend/real-metadata.test.ts
+++ b/console/web/src/lib/backend/real-metadata.test.ts
@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { buildTurnMetadata, FALLBACK_FUNCTION_POLICY } from './real'
+import {
+  buildTurnMetadata,
+  FALLBACK_FUNCTION_POLICY,
+  toProviderOptions,
+  toThinkingLevel,
+} from './real'
 
 describe('buildTurnMetadata — fs_scope forwarding', () => {
   it('carries fs_scope.root when a directory is set', () => {
@@ -25,3 +30,24 @@ describe('fallback function policy', () => {
     expect(FALLBACK_FUNCTION_POLICY.deny).toContain('shell::workspace::*')
   })
 })
+
+describe('model reasoning effort forwarding', () => {
+  it('omits the generic level for default', () => {
+    expect(toThinkingLevel('default')).toBeUndefined()
+    expect(toProviderOptions('openai-codex', 'default')).toBeUndefined()
+  })
+
+  it('forwards native efforts in the selected provider namespace', () => {
+    expect(toThinkingLevel('ultra')).toBeUndefined()
+    expect(toProviderOptions('openai-codex', 'ultra')).toEqual({
+      'openai-codex': { reasoning_effort: 'ultra' },
+    })
+  })
+
+  it('keeps known levels on the generic compatibility field too', () => {
+    expect(toThinkingLevel('high')).toBe('high')
+    expect(toProviderOptions('openai-codex', 'high')).toEqual({
+      'openai-codex': { reasoning_effort: 'high' },
+    })
+  })
+})
diff --git a/console/web/src/lib/backend/real.ts b/console/web/src/lib/backend/real.ts
index 459e105ac..e9686a9b3 100644
--- a/console/web/src/lib/backend/real.ts
+++ b/console/web/src/lib/backend/real.ts
@@ -84,11 +84,29 @@ function resolveRunParams(model: ModelId): RunParams {
   return { provider, model }
 }
 
-/** The harness omits `thinking_level` entirely when the user picks 'off'. */
-function toThinkingLevel(
+/** Generic compatibility value for providers that consume `thinking_level`. */
+export function toThinkingLevel(
   level: ChatStreamOptions['thinkingLevel'],
 ): HarnessThinkingLevel | undefined {
-  return level && level !== 'off' ? level : undefined
+  switch (level) {
+    case 'minimal':
+    case 'low':
+    case 'medium':
+    case 'high':
+    case 'xhigh':
+      return level
+    default:
+      return undefined
+  }
+}
+
+/** Exact model-native effort, routed only to the selected provider. */
+export function toProviderOptions(
+  provider: string,
+  effort: ChatStreamOptions['thinkingLevel'],
+): Record<string, unknown> | undefined {
+  if (!effort || effort === 'default') return undefined
+  return { [provider]: { reasoning_effort: effort } }
 }
 
 /** Build `harness::send` `options.metadata` for filesystem scope. */
@@ -139,6 +157,7 @@ async function buildSendRequest(
 ): Promise<HarnessSendRequest> {
   const { provider, model: modelId } = resolveRunParams(model)
   const thinkingLevel = toThinkingLevel(opts?.thinkingLevel)
+  const providerOptions = toProviderOptions(provider, opts?.thinkingLevel)
 
   let functionPolicy = FALLBACK_FUNCTION_POLICY
   try {
@@ -165,6 +184,7 @@ async function buildSendRequest(
       mode,
       functions: functionPolicy,
       ...(thinkingLevel ? { thinking_level: thinkingLevel } : {}),
+      ...(providerOptions ? { provider_options: providerOptions } : {}),
       metadata: buildTurnMetadata(sessionId, messageId, opts?.workingDir),
     },
   }
diff --git a/console/web/src/lib/backend/types.ts b/console/web/src/lib/backend/types.ts
index 66c1c53c8..3ba26b21f 100644
--- a/console/web/src/lib/backend/types.ts
+++ b/console/web/src/lib/backend/types.ts
@@ -103,9 +103,8 @@ export type StreamEvent =
 export interface ChatStreamOptions {
   signal?: AbortSignal
   /**
-   * Reasoning/thinking level for the turn. Sent to `harness::send` as
-   * `options.thinking_level`; omitted when 'off' or absent. The provider
-   * degrades with a warning when the model can't honor it.
+   * Reasoning effort for the turn. `default` omits the override; exact native
+   * values also travel through namespaced provider options.
    */
   thinkingLevel?: import('@/types/chat').ThinkingLevel
   /**
diff --git a/console/web/src/lib/models-catalog.test.ts b/console/web/src/lib/models-catalog.test.ts
new file mode 100644
index 000000000..6870f893e
--- /dev/null
+++ b/console/web/src/lib/models-catalog.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+import {
+  type CatalogModelRow,
+  catalogRowsToModelOptions,
+} from './models-catalog'
+
+describe('catalogRowsToModelOptions', () => {
+  it('preserves model-specific effort order and descriptions', () => {
+    const rows: CatalogModelRow[] = [
+      {
+        id: 'codex/gpt-5.6-sol',
+        provider: 'openai-codex',
+        display_name: 'GPT-5.6-Sol (Codex)',
+        supports_thinking: true,
+        reasoning_efforts: [
+          { effort: 'low', description: 'fast responses' },
+          { effort: 'xhigh', description: 'extra high reasoning' },
+          { effort: 'ultra', description: 'delegated reasoning' },
+        ],
+      },
+    ]
+
+    expect(catalogRowsToModelOptions(rows)[0]).toMatchObject({
+      id: 'openai-codex::codex/gpt-5.6-sol',
+      reasoningEfforts: [
+        { effort: 'low', description: 'fast responses' },
+        { effort: 'xhigh', description: 'extra high reasoning' },
+        { effort: 'ultra', description: 'delegated reasoning' },
+      ],
+    })
+  })
+})
diff --git a/console/web/src/lib/models-catalog.ts b/console/web/src/lib/models-catalog.ts
index ef75fe1fc..547701f2e 100644
--- a/console/web/src/lib/models-catalog.ts
+++ b/console/web/src/lib/models-catalog.ts
@@ -1,6 +1,6 @@
 import { makeCatalogModelKey } from '@/lib/catalog-model-key'
 import { getIiiClient } from '@/lib/iii-client'
-import type { ModelOption } from '@/types/chat'
+import type { ModelOption, ReasoningEffortOption } from '@/types/chat'
 
 /** Wire shape returned by `router::models::list` over the iii bus. */
 export interface CatalogModelRow {
@@ -9,6 +9,28 @@ export interface CatalogModelRow {
   display_name: string
   context_window?: number
   supports_thinking?: boolean
+  reasoning_efforts?: ReasoningEffortOption[]
+}
+
+function parseReasoningEfforts(
+  value: unknown,
+): ReasoningEffortOption[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  const seen = new Set<string>()
+  const efforts: ReasoningEffortOption[] = []
+  for (const raw of value) {
+    if (!raw || typeof raw !== 'object') continue
+    const row = raw as Record<string, unknown>
+    const effort = typeof row.effort === 'string' ? row.effort.trim() : ''
+    if (!effort || seen.has(effort)) continue
+    seen.add(effort)
+    const description =
+      typeof row.description === 'string' && row.description.trim()
+        ? row.description.trim()
+        : undefined
+    efforts.push({ effort, description })
+  }
+  return efforts.length > 0 ? efforts : undefined
 }
 
 export async function fetchModelsCatalog(): Promise<CatalogModelRow[]> {
@@ -33,8 +55,16 @@ export async function fetchModelsCatalog(): Promise<CatalogModelRow[]> {
         : undefined
     const supports_thinking =
       typeof o.supports_thinking === 'boolean' ? o.supports_thinking : undefined
+    const reasoning_efforts = parseReasoningEfforts(o.reasoning_efforts)
     if (!id || !provider) continue
-    out.push({ id, provider, display_name, context_window, supports_thinking })
+    out.push({
+      id,
+      provider,
+      display_name,
+      context_window,
+      supports_thinking,
+      reasoning_efforts,
+    })
   }
   return out
 }
@@ -50,6 +80,7 @@ export function catalogRowsToModelOptions(
     label: m.display_name.toLowerCase(),
     contextWindow: m.context_window,
     supportsThinking: m.supports_thinking === true,
+    reasoningEfforts: m.reasoning_efforts,
   }))
 }
 
@@ -83,15 +114,15 @@ const PROVIDERS_CHANGED_TRIGGER = 'router::provider::changed'
 async function subscribeRouterTrigger(
   fnId: string,
   triggerType: string,
-  onChange: () => void,
+  onChange: (payload: unknown) => void,
 ): Promise<() => void> {
   const client = await getIiiClient()
   let offHandler: (() => void) | undefined
   let offTrigger: (() => void) | undefined
   try {
     // `on()` registers `<fn>::<browserId>`; the trigger targets the same id.
-    offHandler = client.on(fnId, () => {
-      onChange()
+    offHandler = client.on(fnId, (payload) => {
+      onChange(payload)
     })
     offTrigger = client.registerTrigger({
       type: triggerType,
@@ -129,27 +160,34 @@ async function subscribeRouterTrigger(
 export async function subscribeModelChanges(
   onChange: () => void,
 ): Promise<() => void> {
-  return subscribeRouterTrigger(
-    MODELS_CHANGED_FN,
-    MODELS_CHANGED_TRIGGER,
-    onChange,
+  return subscribeRouterTrigger(MODELS_CHANGED_FN, MODELS_CHANGED_TRIGGER, () =>
+    onChange(),
   )
 }
 
+export interface ProviderChangedEvent {
+  provider: string
+  op: string
+}
+
 /**
  * Subscribe to `router::provider::changed` — availability flips (a provider
  * worker (re)registered, or a dispatch discovered it gone). Model catalogs
- * survive a provider going down, so ONLY this trigger tells the picker to
- * re-read `router::provider::list` and grey/un-grey the group without a
- * manual refresh.
+ * survive a provider going down, so this trigger updates the existing
+ * provider snapshot and greys/un-greys the group without another list request.
  */
 export async function subscribeProviderChanges(
-  onChange: () => void,
+  onChange: (event: ProviderChangedEvent) => void,
 ): Promise<() => void> {
   return subscribeRouterTrigger(
     PROVIDERS_CHANGED_FN,
     PROVIDERS_CHANGED_TRIGGER,
-    onChange,
+    (payload) => {
+      if (!payload || typeof payload !== 'object') return
+      const row = payload as Record<string, unknown>
+      if (typeof row.provider !== 'string' || typeof row.op !== 'string') return
+      onChange({ provider: row.provider, op: row.op })
+    },
   )
 }
 
diff --git a/console/web/src/types/chat.ts b/console/web/src/types/chat.ts
index 35baeaaf5..6cf12c4cf 100644
--- a/console/web/src/types/chat.ts
+++ b/console/web/src/types/chat.ts
@@ -10,6 +10,12 @@ export interface ModelOption {
   label: string
   contextWindow?: number
   supportsThinking?: boolean
+  reasoningEfforts?: ReasoningEffortOption[]
+}
+
+export interface ReasoningEffortOption {
+  effort: string
+  description?: string
 }
 
 export const MODES: { id: Mode; label: string }[] = [
@@ -20,17 +26,12 @@ export const MODES: { id: Mode; label: string }[] = [
 
 export const DEFAULT_MODE: Mode = 'agent'
 
-/** Reasoning effort sent to harness::send as `thinking_level`; 'off' is omitted. */
-export type ThinkingLevel =
-  | 'off'
-  | 'minimal'
-  | 'low'
-  | 'medium'
-  | 'high'
-  | 'xhigh'
+/** Model-selected reasoning effort. `default` omits every effort override. */
+export type ThinkingLevel = string
 
+/** Compatibility choices for providers that only advertise a thinking flag. */
 export const THINKING_LEVELS: ThinkingLevel[] = [
-  'off',
+  'default',
   'minimal',
   'low',
   'medium',
@@ -38,7 +39,7 @@ export const THINKING_LEVELS: ThinkingLevel[] = [
   'xhigh',
 ]
 
-export const DEFAULT_THINKING_LEVEL: ThinkingLevel = 'off'
+export const DEFAULT_THINKING_LEVEL: ThinkingLevel = 'default'
 
 export type Role = 'user' | 'assistant' | 'thought' | 'function-call'
 
diff --git a/harness/Makefile b/harness/Makefile
index 760aa5c9f..6bf0ac878 100644
--- a/harness/Makefile
+++ b/harness/Makefile
@@ -16,7 +16,7 @@ ENGINE_CONFIG ?= $(MAKEFILE_DIR)engine.config.yaml
 STACK := iii-directory llm-router session-manager context-manager \
          provider-anthropic provider-openai provider-openai-codex shell web harness approval-gate console
 
-GOAL_ARGS        := $(filter-out help install-iii-next build install-local clean dev-up dev-down dev-restart \
+GOAL_ARGS        := $(filter-out help install-iii-next build install-local clean cargo-clean dev-up dev-down dev-restart \
                     engine wait-engine restart restart-worker stop stop-worker stop-work stop-engine status smoke logs attach \
                     ensure-session require-engine where,$(MAKECMDGOALS))
 SELECTED_WORKERS := $(strip $(GOAL_ARGS))
@@ -28,7 +28,7 @@ RUN_FLAG   := $(if $(filter release,$(RUN_PROFILE)),--release,)
 
 .DEFAULT_GOAL := help
 
-.PHONY: help install-iii-next build install-local clean dev-up dev-down dev-restart engine wait-engine \
+.PHONY: help install-iii-next build install-local clean cargo-clean dev-up dev-down dev-restart engine wait-engine \
         restart restart-worker stop stop-worker stop-work stop-engine status smoke logs attach ensure-session require-engine where $(STACK)
 
 help:
@@ -48,6 +48,7 @@ help:
 	  '  make where                          print source roots, refs, and tmux panes' \
 	  '  make logs                           attach to the tmux session' \
 	  '  make build [workers...]             cargo build stack or selected workers' \
+	  '  make cargo-clean [workers...]       cargo clean stack or selected workers' \
 	  '  make install-local [workers...]     build and symlink into ~/.iii/workers'
 
 install-iii-next:
@@ -77,6 +78,19 @@ install-local: build
 clean:
 	@for w in $(STACK); do rm -f "$(III_WORKERS)/$$w"; done
 
+cargo-clean:
+	@if [ -n "$(UNKNOWN_WORKERS)" ]; then \
+	  echo "unknown worker(s): $(UNKNOWN_WORKERS)"; \
+	  echo "valid workers: $(STACK)"; \
+	  exit 2; \
+	fi
+	@for w in $(ACTIVE_WORKERS); do \
+	  manifest="$(WORKTREE_ROOT_ABS)/$$w/Cargo.toml"; \
+	  test -f "$$manifest" || { echo "missing $$manifest"; exit 2; }; \
+	  echo "cleaning cargo artifacts for $$w from $(WORKTREE_ROOT_ABS)"; \
+	  cargo clean --manifest-path "$$manifest" || exit 1; \
+	done
+
 dev-up: engine wait-engine
 	@$(MAKE) --no-print-directory restart $(STACK)
 	@$(MAKE) --no-print-directory status
diff --git a/harness/src/clients/router.rs b/harness/src/clients/router.rs
index e78d2e9c2..1b1f788ab 100644
--- a/harness/src/clients/router.rs
+++ b/harness/src/clients/router.rs
@@ -42,6 +42,7 @@ pub struct ChatParams {
     pub tools: Vec<AgentFunction>,
     pub response_format: Option<Value>,
     pub thinking_level: Option<ThinkingLevel>,
+    pub provider_options: Option<Value>,
 }
 
 /// The assembled result of one stream.
@@ -131,6 +132,9 @@ impl RouterClient {
         if let Some(tl) = &params.thinking_level {
             payload["thinking_level"] = serde_json::to_value(tl).unwrap_or(Value::Null);
         }
+        if let Some(options) = &params.provider_options {
+            payload["provider_options"] = options.clone();
+        }
 
         // Run the held-open trigger concurrently with frame consumption.
         //
diff --git a/harness/src/functions/send.rs b/harness/src/functions/send.rs
index fb593822b..532be2769 100644
--- a/harness/src/functions/send.rs
+++ b/harness/src/functions/send.rs
@@ -2,6 +2,8 @@
 //! user message, and CAS-seed the first turn step (or merge into a running
 //! turn). Returns fast (harness.md § `harness::send`).
 
+use std::collections::BTreeMap;
+
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -41,6 +43,9 @@ pub struct SendOptions {
     pub max_turns: Option<u32>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub thinking_level: Option<ThinkingLevel>,
+    /// Provider-native per-call options, namespaced by provider id.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider_options: Option<BTreeMap<String, Value>>,
     /// The turn's deliverable; default `{ type: "text" }`.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub output: Option<OutputContract>,
@@ -452,6 +457,7 @@ fn build_options(cfg: &WorkerConfig, req: &SendRequest, identity: Option<&str>)
         mode: opts.mode,
         max_turns: opts.max_turns.unwrap_or(cfg.default_max_turns),
         thinking_level: opts.thinking_level,
+        provider_options: opts.provider_options,
         output: opts.output.unwrap_or_default(),
         functions: opts.functions,
         metadata: opts.metadata,
diff --git a/harness/src/subagent.rs b/harness/src/subagent.rs
index a19d9ad10..fd806201c 100644
--- a/harness/src/subagent.rs
+++ b/harness/src/subagent.rs
@@ -255,6 +255,7 @@ async fn seed_child(
             mode: req.options.as_ref().and_then(|o| o.mode),
             max_turns,
             thinking_level: req.options.as_ref().and_then(|o| o.thinking_level),
+            provider_options: None,
             output: req
                 .options
                 .as_ref()
@@ -386,6 +387,7 @@ mod tests {
                 mode: None,
                 max_turns: 16,
                 thinking_level: None,
+                provider_options: None,
                 output: OutputContract::Text,
                 functions: None,
                 metadata,
diff --git a/harness/src/turn_loop.rs b/harness/src/turn_loop.rs
index 8e2eab7c6..3750c1bd2 100644
--- a/harness/src/turn_loop.rs
+++ b/harness/src/turn_loop.rs
@@ -332,6 +332,11 @@ pub async fn run_step(
         tools,
         response_format: strategy.response_format(),
         thinking_level: record.options.thinking_level,
+        provider_options: record
+            .options
+            .provider_options
+            .as_ref()
+            .and_then(|options| serde_json::to_value(options).ok()),
     };
     record.stream_request_id = Some(params.request_id.clone());
     crate::state::put_turn(&deps.iii, &record, cfg.session_timeout_ms).await?;
diff --git a/harness/src/types/mod.rs b/harness/src/types/mod.rs
index af5ac2fb3..5e5a22c1d 100644
--- a/harness/src/types/mod.rs
+++ b/harness/src/types/mod.rs
@@ -16,7 +16,7 @@ pub use message::{
     empty_assistant, AgentMessage, AssistantMessage, AssistantRoleTag, CustomMessage,
     CustomRoleTag, FunctionResultMessage, FunctionResultRoleTag, UserMessage, UserRoleTag,
 };
-pub use model::{AgentFunction, Model, Pricing, ThinkingLevel};
+pub use model::{AgentFunction, Model, Pricing, ReasoningEffort, ThinkingLevel};
 pub use output::OutputContract;
 pub use turn::{
     CallCheckpoint, CallState, ExposeMode, FunctionPolicy, IdemRecord, ParentLink, TurnOptions,
diff --git a/harness/src/types/model.rs b/harness/src/types/model.rs
index bd534001d..5ace2742c 100644
--- a/harness/src/types/model.rs
+++ b/harness/src/types/model.rs
@@ -19,6 +19,14 @@ pub enum ThinkingLevel {
     Xhigh,
 }
 
+/// One provider-native reasoning effort advertised for a specific model.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+pub struct ReasoningEffort {
+    pub effort: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+
 #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct Pricing {
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -46,6 +54,8 @@ pub struct Model {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub supports_xhigh: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning_efforts: Option<Vec<ReasoningEffort>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub supports_tools: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub supports_vision: Option<bool>,
diff --git a/harness/src/types/turn.rs b/harness/src/types/turn.rs
index 59f0bb392..d60545988 100644
--- a/harness/src/types/turn.rs
+++ b/harness/src/types/turn.rs
@@ -77,6 +77,8 @@ pub struct TurnOptions {
     pub max_turns: u32,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub thinking_level: Option<ThinkingLevel>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub provider_options: Option<BTreeMap<String, Value>>,
     #[serde(default)]
     pub output: OutputContract,
     /// The dispatch policy; `None` denies every call.
@@ -293,6 +295,7 @@ mod tests {
                 mode: None,
                 max_turns: 16,
                 thinking_level: None,
+                provider_options: None,
                 output: OutputContract::Text,
                 functions: None,
                 metadata: None,
diff --git a/harness/tests/golden/schemas/harness.send.json b/harness/tests/golden/schemas/harness.send.json
index a9f24d47b..d4d08e588 100644
--- a/harness/tests/golden/schemas/harness.send.json
+++ b/harness/tests/golden/schemas/harness.send.json
@@ -473,6 +473,14 @@
             ],
             "description": "The turn's deliverable; default `{ type: \"text\" }`."
           },
+          "provider_options": {
+            "additionalProperties": true,
+            "description": "Provider-native per-call options, namespaced by provider id.",
+            "type": [
+              "object",
+              "null"
+            ]
+          },
           "system_prompt": {
             "type": [
               "string",
diff --git a/llm-router/src/catalog/queries.rs b/llm-router/src/catalog/queries.rs
index 8ef8bf4ca..f286394c4 100644
--- a/llm-router/src/catalog/queries.rs
+++ b/llm-router/src/catalog/queries.rs
@@ -85,6 +85,7 @@ mod tests {
             input_limit: None,
             supports_thinking: Some(true),
             supports_xhigh: Some(false),
+            reasoning_efforts: None,
             supports_tools: Some(true),
             supports_vision: Some(true),
             supports_cache: None,
diff --git a/llm-router/src/types/model.rs b/llm-router/src/types/model.rs
index 5179e895e..2dd1434c1 100644
--- a/llm-router/src/types/model.rs
+++ b/llm-router/src/types/model.rs
@@ -16,6 +16,17 @@ pub enum ThinkingLevel {
     Xhigh,
 }
 
+/// One provider-native reasoning effort advertised for a specific model.
+///
+/// Values intentionally remain strings: provider catalogs can add efforts
+/// without requiring a router-wide enum release first.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+pub struct ReasoningEffort {
+    pub effort: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+
 #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct Pricing {
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -44,6 +55,8 @@ pub struct Model {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub supports_xhigh: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning_efforts: Option<Vec<ReasoningEffort>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub supports_tools: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub supports_vision: Option<bool>,
diff --git a/llm-router/tests/golden/schemas/router.models.get.json b/llm-router/tests/golden/schemas/router.models.get.json
index 067a1b9d7..603df2011 100644
--- a/llm-router/tests/golden/schemas/router.models.get.json
+++ b/llm-router/tests/golden/schemas/router.models.get.json
@@ -73,6 +73,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -173,6 +182,24 @@
           }
         },
         "type": "object"
+      },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
       }
     },
     "title": "Nullable_ModelGetResponse"
diff --git a/llm-router/tests/golden/schemas/router.models.list.json b/llm-router/tests/golden/schemas/router.models.list.json
index 381a6b523..6cc95f847 100644
--- a/llm-router/tests/golden/schemas/router.models.list.json
+++ b/llm-router/tests/golden/schemas/router.models.list.json
@@ -69,6 +69,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -157,6 +166,24 @@
           }
         },
         "type": "object"
+      },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
       }
     },
     "description": "Output of `router::models::list`.",
diff --git a/llm-router/tests/golden/schemas/router.models.reconcile.json b/llm-router/tests/golden/schemas/router.models.reconcile.json
index 047ed5839..065b33113 100644
--- a/llm-router/tests/golden/schemas/router.models.reconcile.json
+++ b/llm-router/tests/golden/schemas/router.models.reconcile.json
@@ -47,6 +47,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -135,6 +144,24 @@
           }
         },
         "type": "object"
+      },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
       }
     },
     "description": "Input of `router::models::reconcile` — the only catalog write path.",
diff --git a/llm-router/tests/golden/schemas/router.provider.register.json b/llm-router/tests/golden/schemas/router.provider.register.json
index f8c420571..b49de1b5c 100644
--- a/llm-router/tests/golden/schemas/router.provider.register.json
+++ b/llm-router/tests/golden/schemas/router.provider.register.json
@@ -47,6 +47,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -155,6 +164,24 @@
           }
         },
         "type": "object"
+      },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
       }
     },
     "description": "Input of `router::provider::register` — a provider worker's declaration plus the optional re-registration token.",
diff --git a/provider-anthropic/src/discovery.rs b/provider-anthropic/src/discovery.rs
index ccf019b1b..2479e00e4 100644
--- a/provider-anthropic/src/discovery.rs
+++ b/provider-anthropic/src/discovery.rs
@@ -84,6 +84,7 @@ fn model_from_live(row: &Value) -> Option<Model> {
             adaptive.or(thinking)
         },
         supports_xhigh: cap_supported(row, &["effort", "xhigh"]),
+        reasoning_efforts: None,
         supports_tools: Some(true), // uniform across the Messages API
         supports_vision: cap_supported(row, &["image_input"]),
         supports_cache: Some(true),
diff --git a/provider-anthropic/src/thinking.rs b/provider-anthropic/src/thinking.rs
index 391b23288..1c0a20a76 100644
--- a/provider-anthropic/src/thinking.rs
+++ b/provider-anthropic/src/thinking.rs
@@ -95,6 +95,7 @@ mod tests {
             input_limit: None,
             supports_thinking: thinking,
             supports_xhigh: xhigh,
+            reasoning_efforts: None,
             supports_tools: Some(true),
             supports_vision: Some(true),
             supports_cache: Some(true),
diff --git a/provider-anthropic/tests/golden/schemas/provider.anthropic.stream.json b/provider-anthropic/tests/golden/schemas/provider.anthropic.stream.json
index 66f8a0a8a..7c0654f24 100644
--- a/provider-anthropic/tests/golden/schemas/provider.anthropic.stream.json
+++ b/provider-anthropic/tests/golden/schemas/provider.anthropic.stream.json
@@ -419,6 +419,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -508,6 +517,24 @@
         },
         "type": "object"
       },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
+      },
       "ResponseFormat": {
         "properties": {
           "schema": true,
diff --git a/provider-llamacpp/src/discovery.rs b/provider-llamacpp/src/discovery.rs
index b59f5e665..668b99ade 100644
--- a/provider-llamacpp/src/discovery.rs
+++ b/provider-llamacpp/src/discovery.rs
@@ -70,6 +70,7 @@ fn enrich(id: &str, props: &Props) -> Model {
         input_limit: None,
         supports_thinking: None,
         supports_xhigh: None,
+        reasoning_efforts: None,
         // Best-effort: requires the server run with --jinja and a
         // tool-capable chat template, which `/props` doesn't report;
         // llama.cpp silently ignores tools a template can't use, so this
diff --git a/provider-llamacpp/src/sse.rs b/provider-llamacpp/src/sse.rs
index c34d7e814..375420677 100644
--- a/provider-llamacpp/src/sse.rs
+++ b/provider-llamacpp/src/sse.rs
@@ -318,6 +318,7 @@ pub fn handle_chunk(
                         events.push(AssistantMessageEvent::FunctioncallDelta {
                             partial: build_partial(state, model),
                             delta: args.to_string(),
+                            id: state.function_calls[index].id.clone(),
                         });
                     }
                 }
diff --git a/provider-llamacpp/tests/golden/schemas/provider.llamacpp.stream.json b/provider-llamacpp/tests/golden/schemas/provider.llamacpp.stream.json
index 19b0cdd8c..76a651a6c 100644
--- a/provider-llamacpp/tests/golden/schemas/provider.llamacpp.stream.json
+++ b/provider-llamacpp/tests/golden/schemas/provider.llamacpp.stream.json
@@ -419,6 +419,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -508,6 +517,24 @@
         },
         "type": "object"
       },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
+      },
       "ResponseFormat": {
         "properties": {
           "schema": true,
diff --git a/provider-openai-codex/src/discovery.rs b/provider-openai-codex/src/discovery.rs
index 899e6a45d..5e46852a0 100644
--- a/provider-openai-codex/src/discovery.rs
+++ b/provider-openai-codex/src/discovery.rs
@@ -10,7 +10,7 @@ use crate::{auth, router_client, state as registration_state, PROVIDER_ID};
 use futures::future::BoxFuture;
 use iii_sdk::errors::Error;
 use iii_sdk::IIIClient;
-use llm_router::types::model::Model;
+use llm_router::types::model::{Model, ReasoningEffort};
 use llm_router::types::router::{
     CredentialSource, ProviderResolveResponse, RefreshModelsRequest, RefreshModelsResponse,
 };
@@ -74,6 +74,8 @@ struct CodexModel {
 #[derive(Debug, Deserialize)]
 struct ReasoningLevel {
     effort: String,
+    #[serde(default)]
+    description: Option<String>,
 }
 
 fn provider_error(code: &str, message: impl Into<String>) -> Error {
@@ -122,6 +124,16 @@ fn map_models(mut remote: Vec<CodexModel>) -> Vec<Model> {
                 .supported_reasoning_levels
                 .iter()
                 .any(|level| level.effort == "xhigh");
+            let reasoning_efforts = (!model.supported_reasoning_levels.is_empty()).then(|| {
+                model
+                    .supported_reasoning_levels
+                    .iter()
+                    .map(|level| ReasoningEffort {
+                        effort: level.effort.clone(),
+                        description: level.description.clone(),
+                    })
+                    .collect()
+            });
             let supports_vision = model
                 .input_modalities
                 .iter()
@@ -138,6 +150,7 @@ fn map_models(mut remote: Vec<CodexModel>) -> Vec<Model> {
                 input_limit: None,
                 supports_thinking: Some(supports_thinking),
                 supports_xhigh: Some(supports_xhigh),
+                reasoning_efforts,
                 supports_tools: Some(true),
                 supports_vision: Some(supports_vision),
                 supports_cache: Some(true),
@@ -284,6 +297,7 @@ mod tests {
             max_output_tokens: None,
             supported_reasoning_levels: vec![ReasoningLevel {
                 effort: "xhigh".into(),
+                description: Some("Extra high reasoning depth".into()),
             }],
             input_modalities: vec!["text".into(), "image".into()],
         }
@@ -291,10 +305,15 @@ mod tests {
 
     #[test]
     fn dynamic_mapping_filters_hidden_sorts_and_namespaces() {
+        let mut first = model("new-first", "list", 1);
+        first.supported_reasoning_levels.push(ReasoningLevel {
+            effort: "ultra".into(),
+            description: Some("Maximum reasoning with delegation".into()),
+        });
         let models = map_models(vec![
             model("old-hidden", "hide", 0),
             model("new-second", "list", 2),
-            model("new-first", "list", 1),
+            first,
         ]);
         assert_eq!(
             models
@@ -306,6 +325,22 @@ mod tests {
         assert_eq!(models[0].context_window, 272_000);
         assert_eq!(models[0].supports_xhigh, Some(true));
         assert_eq!(models[0].supports_vision, Some(true));
+        assert_eq!(
+            models[0].reasoning_efforts.as_deref(),
+            Some(
+                [
+                    ReasoningEffort {
+                        effort: "xhigh".into(),
+                        description: Some("Extra high reasoning depth".into()),
+                    },
+                    ReasoningEffort {
+                        effort: "ultra".into(),
+                        description: Some("Maximum reasoning with delegation".into()),
+                    },
+                ]
+                .as_slice(),
+            )
+        );
     }
 
     #[test]
diff --git a/provider-openai-codex/src/reasoning.rs b/provider-openai-codex/src/reasoning.rs
index 7f2a24fd3..461f51a38 100644
--- a/provider-openai-codex/src/reasoning.rs
+++ b/provider-openai-codex/src/reasoning.rs
@@ -1,7 +1,8 @@
 //! thinking_level → Chat Completions `reasoning_effort`, per model family.
 //! Each ladder branch traces to a documented 400 from the API — a wrong
 //! effort string fails the whole request.
-use llm_router::types::model::ThinkingLevel;
+use llm_router::types::model::{Model, ThinkingLevel};
+use serde_json::Value;
 
 /// Full effort vocabulary in ascending order (superset across families).
 const EFFORT_ORDER: [&str; 6] = ["none", "minimal", "low", "medium", "high", "xhigh"];
@@ -99,6 +100,38 @@ pub fn reasoning_effort_for(level: Option<ThinkingLevel>, model: &str) -> Option
         .copied()
 }
 
+/// Read and validate an exact provider-native effort from this provider's
+/// `provider_options` slice. When catalog metadata is available it is the
+/// authority; an absent catalog keeps the option permissive for cold starts.
+pub fn native_reasoning_effort(
+    provider_options: Option<&Value>,
+    model_meta: Option<&Model>,
+) -> Result<Option<String>, String> {
+    let Some(value) = provider_options.and_then(|options| options.get("reasoning_effort")) else {
+        return Ok(None);
+    };
+    let Some(effort) = value
+        .as_str()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+    else {
+        return Err("reasoning_effort must be a non-empty string".into());
+    };
+    if let Some(supported) = model_meta.and_then(|model| model.reasoning_efforts.as_ref()) {
+        if !supported.iter().any(|option| option.effort == effort) {
+            let allowed = supported
+                .iter()
+                .map(|option| option.effort.as_str())
+                .collect::<Vec<_>>()
+                .join(", ");
+            return Err(format!(
+                "reasoning effort {effort:?} is not supported by this model; choose one of: {allowed}"
+            ));
+        }
+    }
+    Ok(Some(effort.to_string()))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -176,4 +209,43 @@ mod tests {
     fn absent_level_omits_the_param() {
         assert_eq!(reasoning_effort_for(None, "gpt-5.2"), None);
     }
+
+    #[test]
+    fn native_effort_uses_model_specific_catalog() {
+        use llm_router::types::model::ReasoningEffort;
+
+        let model = Model {
+            id: "codex/gpt-5.6-sol".into(),
+            provider: "openai-codex".into(),
+            display_name: None,
+            context_window: 128_000,
+            max_output_tokens: 128_000,
+            input_limit: None,
+            supports_thinking: Some(true),
+            supports_xhigh: Some(true),
+            reasoning_efforts: Some(vec![ReasoningEffort {
+                effort: "ultra".into(),
+                description: Some("Maximum reasoning with delegation".into()),
+            }]),
+            supports_tools: Some(true),
+            supports_vision: Some(true),
+            supports_cache: Some(true),
+            supports_structured_output: None,
+            thinking_budgets: None,
+            pricing: None,
+        };
+        assert_eq!(
+            native_reasoning_effort(
+                Some(&serde_json::json!({ "reasoning_effort": "ultra" })),
+                Some(&model),
+            ),
+            Ok(Some("ultra".into()))
+        );
+        assert!(native_reasoning_effort(
+            Some(&serde_json::json!({ "reasoning_effort": "minimal" })),
+            Some(&model),
+        )
+        .unwrap_err()
+        .contains("choose one of: ultra"));
+    }
 }
diff --git a/provider-openai-codex/src/request.rs b/provider-openai-codex/src/request.rs
index b7520f0de..53d5fc66d 100644
--- a/provider-openai-codex/src/request.rs
+++ b/provider-openai-codex/src/request.rs
@@ -20,7 +20,7 @@ pub struct BodyArgs {
     pub messages: Vec<AgentMessage>,
     pub tools: Vec<AgentFunction>,
     /// Pre-resolved reasoning effort; None omits the param.
-    pub reasoning_effort: Option<&'static str>,
+    pub reasoning_effort: Option<String>,
 }
 
 /// Responses body: `input` items, `stream`, `store:false` (stateless — the
@@ -40,7 +40,7 @@ pub fn build_body(args: &BodyArgs) -> Value {
     if !wire_tools.is_empty() {
         body["tools"] = Value::Array(wire_tools);
     }
-    if let Some(effort) = args.reasoning_effort {
+    if let Some(effort) = &args.reasoning_effort {
         body["reasoning"] = json!({ "effort": effort });
     }
     body
@@ -119,7 +119,7 @@ mod tests {
     #[test]
     fn reasoning_and_tools_serialize_when_present() {
         let mut a = args();
-        a.reasoning_effort = Some("high");
+        a.reasoning_effort = Some("high".into());
         a.tools = vec![AgentFunction {
             name: "agent::trigger".into(),
             description: "d".into(),
diff --git a/provider-openai-codex/src/stream_fn.rs b/provider-openai-codex/src/stream_fn.rs
index ed310f2ed..6c2bb13f3 100644
--- a/provider-openai-codex/src/stream_fn.rs
+++ b/provider-openai-codex/src/stream_fn.rs
@@ -4,7 +4,7 @@
 //! live in the oauth-openai-codex worker / auth-credentials vault — this
 //! provider only *triggers* a refresh when the token is near expiry.
 use crate::config::build_config;
-use crate::reasoning::{is_reasoning_model, reasoning_effort_for};
+use crate::reasoning::{is_reasoning_model, native_reasoning_effort, reasoning_effort_for};
 use crate::request::{build_body, build_headers, BodyArgs};
 use crate::sse::synthetic_error_event;
 use crate::upstream::{spawn_upstream, UpstreamArgs};
@@ -94,7 +94,20 @@ async fn run_stream_call(
         Some(m) => Some(m),
         None => router_client::models_get(iii, &model).await,
     };
-    let reasoning_effort = if is_reasoning_model(
+    let native_effort =
+        match native_reasoning_effort(input.provider_options.as_ref(), model_meta.as_ref()) {
+            Ok(effort) => effort,
+            Err(message) => {
+                let _ = send_event(
+                    sink,
+                    &synthetic_error_event(&message, &model, ErrorKind::Permanent),
+                );
+                return;
+            }
+        };
+    let reasoning_effort = if native_effort.is_some() {
+        native_effort
+    } else if is_reasoning_model(
         &cfg.model,
         model_meta.as_ref().and_then(|m| m.supports_thinking),
     ) {
@@ -105,7 +118,7 @@ async fn run_stream_call(
                 cfg.model
             ));
         }
-        effort
+        effort.map(str::to_string)
     } else {
         if input.thinking_level.is_some() {
             warnings.push(format!(
diff --git a/provider-openai-codex/tests/golden/schemas/provider.openai-codex.stream.json b/provider-openai-codex/tests/golden/schemas/provider.openai-codex.stream.json
index f96745f3f..22e6f6274 100644
--- a/provider-openai-codex/tests/golden/schemas/provider.openai-codex.stream.json
+++ b/provider-openai-codex/tests/golden/schemas/provider.openai-codex.stream.json
@@ -419,6 +419,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -508,6 +517,24 @@
         },
         "type": "object"
       },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
+      },
       "ResponseFormat": {
         "properties": {
           "schema": true,
diff --git a/provider-openai/Cargo.lock b/provider-openai/Cargo.lock
index d550d43a0..617dc8a67 100644
--- a/provider-openai/Cargo.lock
+++ b/provider-openai/Cargo.lock
@@ -776,7 +776,7 @@ checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
 
 [[package]]
 name = "llm-router"
-version = "1.0.6"
+version = "1.0.7"
 dependencies = [
  "async-trait",
  "clap",
diff --git a/provider-openai/Cargo.toml b/provider-openai/Cargo.toml
index 0db6db2ad..8579f239c 100644
--- a/provider-openai/Cargo.toml
+++ b/provider-openai/Cargo.toml
@@ -9,7 +9,7 @@ version = "1.0.7"
 edition = "2021"
 publish = false
 license = "Apache-2.0"
-description = "OpenAI Chat Completions provider worker behind llm-router."
+description = "OpenAI Responses provider worker behind llm-router."
 
 [[bin]]
 name = "provider-openai"
diff --git a/provider-openai/README.md b/provider-openai/README.md
index 00a387ec5..263d90db7 100644
--- a/provider-openai/README.md
+++ b/provider-openai/README.md
@@ -1,6 +1,7 @@
 # provider-openai
 
-OpenAI Chat Completions provider worker behind [llm-router](../llm-router/).
+OpenAI Responses provider worker behind [llm-router](../llm-router/), with a
+Chat Completions compatibility path for custom gateways.
 Implements the provider protocol from
 `tech-specs/2026-06-agentic/llm-router.md`: `provider::openai::stream`
 (SSE chunks → `AssistantMessageEvent` frames into a router-owned channel) and
@@ -12,8 +13,12 @@ chat/reasoning families ∪ curated capability snapshot →
 
 - **Registration:** self-declares via `router::provider::register` with
   backoff until acked, and re-declares on the `router::ready` trigger type.
-  The declaration ships a static curated `models` slice (no cold-catalog
-  hole) and `credential_env_var: OPENAI_API_KEY`.
+  The model slice is populated from live discovery and the declaration carries
+  `credential_env_var: OPENAI_API_KEY`.
+- **Transport:** the default `https://api.openai.com/v1/responses` endpoint
+  uses Responses items and typed streaming events. An explicitly configured
+  endpoint that does not end in `/responses` keeps the Chat Completions wire
+  format for compatible gateways that have not migrated.
 - **Identity binding:** the router returns a `registration_token` on first
   registration; it is persisted in iii-state (scope `provider-openai`,
   key `registration_token`) and presented on every later
@@ -35,11 +40,14 @@ chat/reasoning families ∪ curated capability snapshot →
   strict `json_schema` mode; without one, `json_object` mode (the caller
   must mention "JSON" in the prompt per OpenAI's rules). Every curated
   record declares `supports_structured_output: true`.
-- **Reasoning:** `thinking_level` maps to `reasoning_effort` per model
+- **Reasoning:** `thinking_level` maps to the selected transport's reasoning
+  field per model
   family (`src/reasoning.rs` — the ladders encode real 400s: o1 and
   chat-tuned variants take no param, pro is high-only, xhigh is gpt-5.2+).
-  No reasoning text is streamed back on Chat Completions;
-  `completion_tokens_details.reasoning_tokens` lands on `usage.reasoning`.
+  Responses reasoning summaries are relayed as thinking blocks. Chat
+  Completions still exposes only `completion_tokens_details.reasoning_tokens`
+  as `usage.reasoning`. Luna requests with function tools on the legacy path
+  force `reasoning_effort: none`, matching that endpoint's compatibility rule.
 - **Prompt caching:** automatic on OpenAI's side — no request markers.
   `prompt_tokens_details.cached_tokens` lands on `usage.cache_read`.
 - **Curated snapshot:** `src/curated.rs` carries windows / output ceilings /
diff --git a/provider-openai/iii.worker.yaml b/provider-openai/iii.worker.yaml
index df4b6af86..28b182de1 100644
--- a/provider-openai/iii.worker.yaml
+++ b/provider-openai/iii.worker.yaml
@@ -4,7 +4,7 @@ language: rust
 deploy: binary
 manifest: Cargo.toml
 bin: provider-openai
-description: OpenAI Chat Completions provider worker; implements provider::openai::stream and provider::openai::refresh_models behind llm-router.
+description: OpenAI Responses provider worker with Chat Completions compatibility; implements provider::openai::stream and provider::openai::refresh_models behind llm-router.
 
 dependencies:
   iii-state: "^0.21.3"
diff --git a/provider-openai/src/config.rs b/provider-openai/src/config.rs
index c0c5bffe5..ee234e417 100644
--- a/provider-openai/src/config.rs
+++ b/provider-openai/src/config.rs
@@ -5,15 +5,39 @@
 use llm_router::types::credential::Credential;
 use llm_router::types::router::ProviderResolveResponse;
 
-pub const DEFAULT_API_URL: &str = "https://api.openai.com/v1/chat/completions";
+pub const DEFAULT_API_URL: &str = "https://api.openai.com/v1/responses";
 pub const DEFAULT_MAX_TOKENS: u64 = 8192;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ApiMode {
+    Responses,
+    ChatCompletions,
+}
+
+impl ApiMode {
+    /// The endpoint is the compatibility switch: official OpenAI defaults to
+    /// Responses, while an explicitly configured Chat Completions URL keeps
+    /// working for gateways that have not implemented Responses.
+    pub fn from_url(api_url: &str) -> Self {
+        let path = reqwest::Url::parse(api_url)
+            .ok()
+            .map(|url| url.path().trim_end_matches('/').to_string())
+            .unwrap_or_default();
+        if path.ends_with("/responses") {
+            Self::Responses
+        } else {
+            Self::ChatCompletions
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct OpenaiConfig {
     pub credential_value: String,
     pub model: String,
     pub max_tokens: u64,
     pub api_url: String,
+    pub api_mode: ApiMode,
 }
 
 /// Why an effective config could not be built — the caller turns each into a
@@ -78,6 +102,7 @@ pub fn config_from_resolve(
         Ok(u) if matches!(u.scheme(), "http" | "https") => {}
         _ => return Err(ConfigError::InvalidApiUrl(api_url)),
     }
+    let api_mode = ApiMode::from_url(&api_url);
     Ok(OpenaiConfig {
         credential_value,
         model: model.to_string(),
@@ -85,6 +110,7 @@ pub fn config_from_resolve(
             .or(resolved.max_tokens)
             .unwrap_or(DEFAULT_MAX_TOKENS),
         api_url,
+        api_mode,
     })
 }
 
@@ -157,6 +183,7 @@ mod tests {
         )
         .unwrap();
         assert_eq!(cfg.api_url, "https://h/v1");
+        assert_eq!(cfg.api_mode, ApiMode::ChatCompletions);
     }
 
     #[test]
@@ -164,6 +191,23 @@ mod tests {
         let cfg =
             config_from_resolve("m", None, &resolved_with_url(some_key(), Some("   "))).unwrap();
         assert_eq!(cfg.api_url, DEFAULT_API_URL);
+        assert_eq!(cfg.api_mode, ApiMode::Responses);
+    }
+
+    #[test]
+    fn endpoint_path_selects_transport() {
+        assert_eq!(
+            ApiMode::from_url("https://api.openai.com/v1/responses"),
+            ApiMode::Responses
+        );
+        assert_eq!(
+            ApiMode::from_url("https://gateway.test/v1/responses/"),
+            ApiMode::Responses
+        );
+        assert_eq!(
+            ApiMode::from_url("https://gateway.test/v1/chat/completions"),
+            ApiMode::ChatCompletions
+        );
     }
 
     #[test]
diff --git a/provider-openai/src/curated.rs b/provider-openai/src/curated.rs
index e2f703207..7f028da71 100644
--- a/provider-openai/src/curated.rs
+++ b/provider-openai/src/curated.rs
@@ -61,6 +61,7 @@ pub fn enrich(id: &str) -> Model {
             input_limit: None,
             supports_thinking: Some(true),
             supports_xhigh: Some(xhigh),
+            reasoning_efforts: None,
             supports_tools: Some(true),
             supports_vision: Some(true),
             supports_cache: Some(true),
@@ -77,6 +78,7 @@ pub fn enrich(id: &str) -> Model {
             input_limit: None,
             supports_thinking: None,
             supports_xhigh: None,
+            reasoning_efforts: None,
             supports_tools: Some(true),
             supports_vision: None,
             supports_cache: Some(true),
diff --git a/provider-openai/src/discovery.rs b/provider-openai/src/discovery.rs
index 8121f008e..d0ebaa22f 100644
--- a/provider-openai/src/discovery.rs
+++ b/provider-openai/src/discovery.rs
@@ -15,13 +15,14 @@ use llm_router::types::router::{RefreshModelsRequest, RefreshModelsResponse};
 use serde_json::Value;
 use std::collections::HashSet;
 
-/// Derive the models endpoint from the configured completions endpoint
-/// (`…/v1/chat/completions` → `…/v1/models`).
+/// Derive the models endpoint from either supported generation endpoint.
 pub fn models_url(api_url: &str) -> String {
-    match api_url.strip_suffix("/chat/completions") {
-        Some(base) => format!("{base}/models"),
-        None => "https://api.openai.com/v1/models".to_string(),
-    }
+    let trimmed = api_url.trim_end_matches('/');
+    trimmed
+        .strip_suffix("/chat/completions")
+        .or_else(|| trimmed.strip_suffix("/responses"))
+        .map(|base| format!("{base}/models"))
+        .unwrap_or_else(|| "https://api.openai.com/v1/models".to_string())
 }
 
 /// Substrings marking a non-chat modality (embeddings, audio, image, …).
@@ -190,7 +191,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn models_url_derives_from_completions_endpoint() {
+    fn models_url_derives_from_generation_endpoint() {
         assert_eq!(
             models_url("https://api.openai.com/v1/chat/completions"),
             "https://api.openai.com/v1/models"
@@ -199,6 +200,14 @@ mod tests {
             models_url("http://127.0.0.1:9999/v1/chat/completions"),
             "http://127.0.0.1:9999/v1/models"
         );
+        assert_eq!(
+            models_url("https://api.openai.com/v1/responses"),
+            "https://api.openai.com/v1/models"
+        );
+        assert_eq!(
+            models_url("http://127.0.0.1:9999/v1/responses/"),
+            "http://127.0.0.1:9999/v1/models"
+        );
         // unrecognized shape falls back to the public endpoint
         assert_eq!(
             models_url("https://proxy.example/custom"),
diff --git a/provider-openai/src/lib.rs b/provider-openai/src/lib.rs
index c3d1e644b..919728d03 100644
--- a/provider-openai/src/lib.rs
+++ b/provider-openai/src/lib.rs
@@ -1,4 +1,5 @@
-//! provider-openai: OpenAI Chat Completions provider behind llm-router.
+//! provider-openai: OpenAI Responses provider behind llm-router, with a
+//! Chat Completions compatibility path for custom gateways.
 //! Spec: tech-specs/2026-06-agentic/llm-router.md § The provider protocol.
 
 pub mod config;
diff --git a/provider-openai/src/main.rs b/provider-openai/src/main.rs
index f69c1940a..e58a6f137 100644
--- a/provider-openai/src/main.rs
+++ b/provider-openai/src/main.rs
@@ -14,7 +14,7 @@ use provider_openai::register::register_provider;
 #[derive(Parser, Debug)]
 #[command(
     name = "provider-openai",
-    about = "OpenAI Chat Completions provider worker behind llm-router."
+    about = "OpenAI Responses provider worker behind llm-router."
 )]
 struct Cli {
     /// Accepted for the standard worker CLI contract; provider config comes
diff --git a/provider-openai/src/manifest.rs b/provider-openai/src/manifest.rs
index 09060ec5d..87daf50e1 100644
--- a/provider-openai/src/manifest.rs
+++ b/provider-openai/src/manifest.rs
@@ -2,7 +2,7 @@
 //! (binary-worker.md § manifest; same shape as provider-anthropic/src/manifest.rs).
 use serde::Serialize;
 
-const DESCRIPTION: &str = "OpenAI Chat Completions provider worker behind llm-router.";
+const DESCRIPTION: &str = "OpenAI Responses provider worker behind llm-router.";
 
 #[derive(Serialize)]
 pub struct ModuleManifest {
diff --git a/provider-openai/src/reasoning.rs b/provider-openai/src/reasoning.rs
index 7f2a24fd3..b7a668207 100644
--- a/provider-openai/src/reasoning.rs
+++ b/provider-openai/src/reasoning.rs
@@ -1,4 +1,5 @@
-//! thinking_level → Chat Completions `reasoning_effort`, per model family.
+//! thinking_level → the selected OpenAI transport's reasoning effort, per
+//! model family.
 //! Each ladder branch traces to a documented 400 from the API — a wrong
 //! effort string fails the whole request.
 use llm_router::types::model::ThinkingLevel;
diff --git a/provider-openai/src/request.rs b/provider-openai/src/request.rs
index 2c71b1860..7aa4db24d 100644
--- a/provider-openai/src/request.rs
+++ b/provider-openai/src/request.rs
@@ -1,8 +1,8 @@
-//! Full Chat Completions request assembly: body (messages, tools,
-//! reasoning_effort, response_format) + headers.
-use crate::config::OpenaiConfig;
-use crate::wire::messages::to_wire_messages;
-use crate::wire::tools::functions_to_wire;
+//! Request assembly for the Responses API and the legacy Chat Completions
+//! compatibility path.
+use crate::config::{ApiMode, OpenaiConfig};
+use crate::wire::messages::{to_responses_input, to_wire_messages};
+use crate::wire::tools::{functions_to_responses_wire, functions_to_wire};
 use llm_router::types::messages::AgentMessage;
 use llm_router::types::model::AgentFunction;
 use llm_router::types::router::ResponseFormat;
@@ -25,7 +25,7 @@ pub struct BodyArgs {
 /// correct: retrying cannot fix the schema). Without: json_object mode
 /// (OpenAI requires the word "JSON" somewhere in the messages — the
 /// caller's contract per spec § Model capabilities).
-pub fn build_response_format(rf: &ResponseFormat) -> Value {
+pub fn build_chat_response_format(rf: &ResponseFormat) -> Value {
     match &rf.schema {
         Some(schema) => json!({
             "type": "json_schema",
@@ -39,7 +39,7 @@ pub fn build_response_format(rf: &ResponseFormat) -> Value {
 /// and gpt-5 families reject the old param. Reasoning tokens count toward
 /// it; the router-clamped budget leaves ample room. No `temperature`: the
 /// API default applies (reasoning models reject non-default values).
-pub fn build_body(args: &BodyArgs) -> Value {
+fn build_chat_body(args: &BodyArgs) -> Value {
     let mut body = json!({
         "model": args.model,
         "max_completion_tokens": args.max_tokens,
@@ -55,15 +55,57 @@ pub fn build_body(args: &BodyArgs) -> Value {
         body["reasoning_effort"] = json!(effort);
     }
     if let Some(rf) = &args.response_format {
-        body["response_format"] = build_response_format(rf);
+        body["response_format"] = build_chat_response_format(rf);
     }
     body
 }
 
+fn build_responses_text(rf: &ResponseFormat) -> Value {
+    let format = match &rf.schema {
+        Some(schema) => json!({
+            "type": "json_schema",
+            "name": "response",
+            "strict": true,
+            "schema": schema,
+        }),
+        None => json!({ "type": "json_object" }),
+    };
+    json!({ "format": format })
+}
+
+fn build_responses_body(args: &BodyArgs) -> Value {
+    let mut body = json!({
+        "model": args.model,
+        "max_output_tokens": args.max_tokens,
+        "input": to_responses_input(&args.messages, &args.system_prompt),
+        "stream": true,
+        "store": false,
+    });
+    let wire_tools = functions_to_responses_wire(&args.tools);
+    if !wire_tools.is_empty() {
+        body["tools"] = Value::Array(wire_tools);
+    }
+    if let Some(effort) = args.reasoning_effort {
+        body["reasoning"] = json!({ "effort": effort });
+    }
+    if let Some(response_format) = &args.response_format {
+        body["text"] = build_responses_text(response_format);
+    }
+    body
+}
+
+pub fn build_body(args: &BodyArgs, api_mode: ApiMode) -> Value {
+    match api_mode {
+        ApiMode::Responses => build_responses_body(args),
+        ApiMode::ChatCompletions => build_chat_body(args),
+    }
+}
+
 pub fn build_headers(cfg: &OpenaiConfig) -> Vec<(&'static str, String)> {
     vec![
         ("authorization", format!("Bearer {}", cfg.credential_value)),
         ("content-type", "application/json".to_string()),
+        ("accept", "text/event-stream".to_string()),
     ]
 }
 
@@ -91,7 +133,7 @@ mod tests {
 
     #[test]
     fn body_has_required_fields_and_stream_options() {
-        let body = build_body(&args());
+        let body = build_body(&args(), ApiMode::ChatCompletions);
         assert_eq!(body["model"], "gpt-5.2");
         assert_eq!(body["max_completion_tokens"], 4096);
         assert!(
@@ -119,14 +161,14 @@ mod tests {
             label: None,
             execution_mode: None,
         }];
-        let body = build_body(&a);
+        let body = build_body(&a, ApiMode::ChatCompletions);
         assert_eq!(body["reasoning_effort"], "high");
         assert_eq!(body["tools"][0]["function"]["name"], "agent__trigger");
     }
 
     #[test]
     fn response_format_maps_to_json_schema_or_json_object() {
-        let with_schema = build_response_format(&ResponseFormat {
+        let with_schema = build_chat_response_format(&ResponseFormat {
             r#type: "json".into(),
             schema: Some(serde_json::json!({ "type": "object", "additionalProperties": false })),
         });
@@ -135,7 +177,7 @@ mod tests {
         assert_eq!(with_schema["json_schema"]["strict"], true);
         assert_eq!(with_schema["json_schema"]["schema"]["type"], "object");
 
-        let without = build_response_format(&ResponseFormat {
+        let without = build_chat_response_format(&ResponseFormat {
             r#type: "json".into(),
             schema: None,
         });
@@ -146,7 +188,38 @@ mod tests {
             r#type: "json".into(),
             schema: None,
         });
-        assert_eq!(build_body(&a)["response_format"]["type"], "json_object");
+        assert_eq!(
+            build_body(&a, ApiMode::ChatCompletions)["response_format"]["type"],
+            "json_object"
+        );
+    }
+
+    #[test]
+    fn responses_body_uses_items_tools_and_reasoning_object() {
+        let mut a = args();
+        a.reasoning_effort = Some("high");
+        a.tools = vec![AgentFunction {
+            name: "agent::trigger".into(),
+            description: "d".into(),
+            parameters: json!({ "type": "object" }),
+            label: None,
+            execution_mode: None,
+        }];
+        a.response_format = Some(ResponseFormat {
+            r#type: "json".into(),
+            schema: Some(json!({ "type": "object", "additionalProperties": false })),
+        });
+        let body = build_body(&a, ApiMode::Responses);
+        assert_eq!(body["model"], "gpt-5.2");
+        assert_eq!(body["max_output_tokens"], 4096);
+        assert_eq!(body["store"], false);
+        assert_eq!(body["input"][0]["content"][0]["type"], "input_text");
+        assert_eq!(body["tools"][0]["name"], "agent__trigger");
+        assert!(body["tools"][0].get("function").is_none());
+        assert_eq!(body["reasoning"]["effort"], "high");
+        assert_eq!(body["text"]["format"]["type"], "json_schema");
+        assert!(body.get("messages").is_none());
+        assert!(body.get("reasoning_effort").is_none());
     }
 
     #[test]
@@ -156,6 +229,7 @@ mod tests {
             model: "gpt-5.2".into(),
             max_tokens: 4096,
             api_url: "https://api.openai.com/v1/chat/completions".into(),
+            api_mode: ApiMode::ChatCompletions,
         };
         let h = build_headers(&cfg);
         assert!(h.contains(&("authorization", "Bearer sk-test".to_string())));
diff --git a/provider-openai/src/sse.rs b/provider-openai/src/sse.rs
index 075e5cdaf..689f40806 100644
--- a/provider-openai/src/sse.rs
+++ b/provider-openai/src/sse.rs
@@ -1,6 +1,5 @@
-//! Chat Completions chunk → AssistantMessageEvent state machine. Pure:
-//! consumes one parsed chunk at a time, threads it through PartialState,
-//! returns 0+ events. [DONE] is the upstream pump's concern.
+//! OpenAI Chat Completions chunks and Responses events →
+//! AssistantMessageEvent state machine. [DONE] is the upstream pump's concern.
 use crate::errors::classify;
 use crate::wire::names::decode_tool_name;
 use crate::{now_ms, PROVIDER_ID};
@@ -12,6 +11,7 @@ use serde_json::Value;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum OpenBlock {
     Text,
+    Thinking,
     Call(usize),
 }
 
@@ -24,6 +24,7 @@ struct PartialFunctionCall {
 
 pub struct PartialState {
     text: String,
+    thinking: String,
     function_calls: Vec<PartialFunctionCall>,
     open_block: Option<OpenBlock>,
     usage: Usage,
@@ -38,6 +39,7 @@ impl PartialState {
     pub fn new(warnings: Vec<String>) -> Self {
         PartialState {
             text: String::new(),
+            thinking: String::new(),
             function_calls: Vec::new(),
             open_block: None,
             usage: Usage::default(),
@@ -52,6 +54,10 @@ impl PartialState {
     pub fn stop_reason(&self) -> StopReason {
         self.stop_reason
     }
+
+    pub fn has_content(&self) -> bool {
+        !self.text.is_empty() || !self.thinking.is_empty() || !self.function_calls.is_empty()
+    }
 }
 
 pub fn empty_assistant(model: &str) -> AssistantMessage {
@@ -72,6 +78,12 @@ pub fn empty_assistant(model: &str) -> AssistantMessage {
 
 fn build_content(state: &PartialState) -> Vec<ContentBlock> {
     let mut out = Vec::new();
+    if !state.thinking.is_empty() {
+        out.push(ContentBlock::Thinking {
+            text: state.thinking.clone(),
+            signature: None,
+        });
+    }
     if !state.text.is_empty() {
         out.push(ContentBlock::Text {
             text: state.text.clone(),
@@ -159,6 +171,7 @@ pub fn merge_usage(raw: &Value, into: &mut Usage) {
     }
     if let Some(v) = raw
         .pointer("/completion_tokens_details/reasoning_tokens")
+        .or_else(|| raw.pointer("/output_tokens_details/reasoning_tokens"))
         .and_then(Value::as_u64)
     {
         into.reasoning = Some(v);
@@ -187,6 +200,9 @@ fn close_open_block(
         Some(OpenBlock::Text) => events.push(AssistantMessageEvent::TextEnd {
             partial: build_partial(state, model),
         }),
+        Some(OpenBlock::Thinking) => events.push(AssistantMessageEvent::ThinkingEnd {
+            partial: build_partial(state, model),
+        }),
         Some(OpenBlock::Call(_)) => events.push(AssistantMessageEvent::FunctioncallEnd {
             partial: build_partial(state, model),
         }),
@@ -200,6 +216,9 @@ pub fn handle_chunk(
     state: &mut PartialState,
     model: &str,
 ) -> Vec<AssistantMessageEvent> {
+    if chunk.get("type").and_then(Value::as_str).is_some() {
+        return handle_responses_event(chunk, state, model);
+    }
     let mut events = Vec::new();
 
     // Mid-stream error envelope (some gateways send {"error": {...}} as a
@@ -299,6 +318,215 @@ pub fn handle_chunk(
     events
 }
 
+fn string_delta(event: &Value) -> &str {
+    event
+        .get("delta")
+        .and_then(|delta| {
+            delta
+                .as_str()
+                .or_else(|| delta.get("text").and_then(Value::as_str))
+        })
+        .or_else(|| event.get("text").and_then(Value::as_str))
+        .unwrap_or("")
+}
+
+fn responses_usage(event: &Value, state: &mut PartialState) {
+    let usage = event
+        .get("usage")
+        .or_else(|| event.pointer("/response/usage"));
+    if let Some(usage) = usage.filter(|usage| usage.is_object()) {
+        merge_usage(usage, &mut state.usage);
+        state.usage_seen = true;
+    }
+}
+
+fn ensure_function_call(state: &mut PartialState, index: usize) -> &mut PartialFunctionCall {
+    while state.function_calls.len() <= index {
+        state.function_calls.push(PartialFunctionCall::default());
+    }
+    &mut state.function_calls[index]
+}
+
+fn handle_responses_event(
+    event: &Value,
+    state: &mut PartialState,
+    model: &str,
+) -> Vec<AssistantMessageEvent> {
+    let mut events = Vec::new();
+    let name = event.get("type").and_then(Value::as_str).unwrap_or("");
+
+    match name {
+        "response.created" | "response.in_progress" => {}
+        "response.output_item.added" => {
+            let Some(item) = event.get("item").or_else(|| event.get("output_item")) else {
+                return events;
+            };
+            if item.get("type").and_then(Value::as_str) != Some("function_call") {
+                return events;
+            }
+            let index = event
+                .get("output_index")
+                .and_then(Value::as_u64)
+                .unwrap_or(state.function_calls.len() as u64) as usize;
+            let call = ensure_function_call(state, index);
+            call.id = item
+                .get("call_id")
+                .or_else(|| item.get("id"))
+                .and_then(Value::as_str)
+                .unwrap_or("")
+                .to_string();
+            call.function_id = item
+                .get("name")
+                .and_then(Value::as_str)
+                .map(decode_tool_name)
+                .unwrap_or_default();
+            close_open_block(state, model, &mut events);
+            state.open_block = Some(OpenBlock::Call(index));
+            events.push(AssistantMessageEvent::FunctioncallStart {
+                partial: build_partial(state, model),
+            });
+        }
+        "response.output_text.delta" => {
+            let delta = string_delta(event);
+            if delta.is_empty() {
+                return events;
+            }
+            if state.open_block != Some(OpenBlock::Text) {
+                close_open_block(state, model, &mut events);
+                state.open_block = Some(OpenBlock::Text);
+                events.push(AssistantMessageEvent::TextStart {
+                    partial: build_partial(state, model),
+                });
+            }
+            state.text.push_str(delta);
+            events.push(AssistantMessageEvent::TextDelta {
+                partial: build_partial(state, model),
+                delta: delta.to_string(),
+            });
+        }
+        "response.reasoning_summary_text.delta" | "response.reasoning_text.delta" => {
+            let delta = string_delta(event);
+            if delta.is_empty() {
+                return events;
+            }
+            if state.open_block != Some(OpenBlock::Thinking) {
+                close_open_block(state, model, &mut events);
+                state.open_block = Some(OpenBlock::Thinking);
+                events.push(AssistantMessageEvent::ThinkingStart {
+                    partial: build_partial(state, model),
+                });
+            }
+            state.thinking.push_str(delta);
+            events.push(AssistantMessageEvent::ThinkingDelta {
+                partial: build_partial(state, model),
+                delta: delta.to_string(),
+            });
+        }
+        "response.function_call_arguments.delta" => {
+            let delta = string_delta(event);
+            if delta.is_empty() {
+                return events;
+            }
+            let index = event
+                .get("output_index")
+                .and_then(Value::as_u64)
+                .unwrap_or_else(|| state.function_calls.len().saturating_sub(1) as u64)
+                as usize;
+            if state.open_block != Some(OpenBlock::Call(index)) {
+                close_open_block(state, model, &mut events);
+                state.open_block = Some(OpenBlock::Call(index));
+                events.push(AssistantMessageEvent::FunctioncallStart {
+                    partial: build_partial(state, model),
+                });
+            }
+            let call = ensure_function_call(state, index);
+            call.args_json.push_str(delta);
+            let id = call.id.clone();
+            events.push(AssistantMessageEvent::FunctioncallDelta {
+                partial: build_partial(state, model),
+                delta: delta.to_string(),
+                id,
+            });
+        }
+        "response.output_item.done" => {
+            if let Some(item) = event
+                .get("item")
+                .filter(|item| item.get("type").and_then(Value::as_str) == Some("function_call"))
+            {
+                let index = event
+                    .get("output_index")
+                    .and_then(Value::as_u64)
+                    .unwrap_or_else(|| state.function_calls.len().saturating_sub(1) as u64)
+                    as usize;
+                let call = ensure_function_call(state, index);
+                if let Some(arguments) = item.get("arguments").and_then(Value::as_str) {
+                    call.args_json = arguments.to_string();
+                }
+            }
+        }
+        "response.completed" => {
+            responses_usage(event, state);
+            state.stop_reason = if state.function_calls.is_empty() {
+                StopReason::End
+            } else {
+                StopReason::FunctionCall
+            };
+            close_open_block(state, model, &mut events);
+            events.push(AssistantMessageEvent::Stop {
+                stop_reason: state.stop_reason,
+                error_message: None,
+                error_kind: None,
+            });
+            events.push(AssistantMessageEvent::Done {
+                message: build_final(state, model),
+            });
+        }
+        "response.incomplete" => {
+            responses_usage(event, state);
+            let reason = event
+                .pointer("/response/incomplete_details/reason")
+                .and_then(Value::as_str)
+                .unwrap_or("incomplete");
+            if reason == "max_output_tokens" {
+                state.stop_reason = StopReason::Length;
+                state.native_stop_reason = Some(reason.to_string());
+                close_open_block(state, model, &mut events);
+                events.push(AssistantMessageEvent::Stop {
+                    stop_reason: StopReason::Length,
+                    error_message: None,
+                    error_kind: None,
+                });
+                events.push(AssistantMessageEvent::Done {
+                    message: build_final(state, model),
+                });
+            } else {
+                let message = format!("OpenAI response incomplete: {reason}");
+                state.stop_reason = StopReason::Error;
+                state.error_message = Some(message.clone());
+                let mut error = build_final(state, model);
+                error.error_kind = Some(classify(None, &message));
+                events.push(AssistantMessageEvent::Error { error });
+            }
+        }
+        "error" | "response.failed" => {
+            let message = event
+                .pointer("/error/message")
+                .or_else(|| event.pointer("/response/error/message"))
+                .and_then(Value::as_str)
+                .or_else(|| event.get("message").and_then(Value::as_str))
+                .unwrap_or("OpenAI response failed")
+                .to_string();
+            state.stop_reason = StopReason::Error;
+            state.error_message = Some(message.clone());
+            let mut error = build_final(state, model);
+            error.error_kind = Some(classify(None, &message));
+            events.push(AssistantMessageEvent::Error { error });
+        }
+        _ => {}
+    }
+    events
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -530,4 +758,81 @@ mod tests {
             other => panic!("want error, got {other:?}"),
         }
     }
+
+    #[test]
+    fn responses_text_and_usage_complete_the_stream() {
+        let (state, events) = run(&[
+            json!({"type":"response.created"}),
+            json!({"type":"response.output_text.delta","delta":"Hello"}),
+            json!({"type":"response.completed","response":{"usage":{
+                "input_tokens":12,
+                "output_tokens":2,
+                "input_tokens_details":{"cached_tokens":4},
+                "output_tokens_details":{"reasoning_tokens":1}
+            }}}),
+        ]);
+        assert!(matches!(
+            events.last(),
+            Some(AssistantMessageEvent::Done { .. })
+        ));
+        assert_eq!(events.iter().filter(|event| event.is_terminal()).count(), 1);
+        let final_message = build_final(&state, "gpt-test");
+        assert!(
+            matches!(&final_message.content[0], ContentBlock::Text { text } if text == "Hello")
+        );
+        let usage = final_message.usage.unwrap();
+        assert_eq!(usage.input, Some(12));
+        assert_eq!(usage.output, Some(2));
+        assert_eq!(usage.cache_read, Some(4));
+        assert_eq!(usage.reasoning, Some(1));
+    }
+
+    #[test]
+    fn responses_function_call_uses_output_index_and_call_id() {
+        let (state, events) = run(&[
+            json!({"type":"response.output_item.added","output_index":0,"item":{
+                "type":"function_call","call_id":"call_1","name":"shell__exec"
+            }}),
+            json!({"type":"response.function_call_arguments.delta","output_index":0,"delta":"{\"cmd\":"}),
+            json!({"type":"response.function_call_arguments.delta","output_index":0,"delta":"\"ls\"}"}),
+            json!({"type":"response.completed"}),
+        ]);
+        assert!(matches!(
+            events.last(),
+            Some(AssistantMessageEvent::Done { .. })
+        ));
+        let final_message = build_final(&state, "gpt-test");
+        assert_eq!(final_message.stop_reason, StopReason::FunctionCall);
+        match &final_message.content[0] {
+            ContentBlock::FunctionCall {
+                id,
+                function_id,
+                arguments,
+            } => {
+                assert_eq!(id, "call_1");
+                assert_eq!(function_id, "shell::exec");
+                assert_eq!(arguments["cmd"], "ls");
+            }
+            other => panic!("want function call, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn responses_max_output_tokens_maps_to_length() {
+        let (state, events) = run(&[
+            json!({"type":"response.output_text.delta","delta":"partial"}),
+            json!({"type":"response.incomplete","response":{
+                "incomplete_details":{"reason":"max_output_tokens"}
+            }}),
+        ]);
+        assert!(matches!(
+            events.last(),
+            Some(AssistantMessageEvent::Done { .. })
+        ));
+        assert_eq!(state.stop_reason, StopReason::Length);
+        assert_eq!(
+            state.native_stop_reason.as_deref(),
+            Some("max_output_tokens")
+        );
+    }
 }
diff --git a/provider-openai/src/stream_fn.rs b/provider-openai/src/stream_fn.rs
index 3773cbd2d..f2d2583be 100644
--- a/provider-openai/src/stream_fn.rs
+++ b/provider-openai/src/stream_fn.rs
@@ -1,7 +1,7 @@
 //! The `provider::openai::stream` iii function (spec § Provider stream
 //! contract): write AssistantMessageEvent frames as JSON text messages into
 //! the router-owned channel, terminal done/error last, then close.
-use crate::config::config_from_resolve;
+use crate::config::{config_from_resolve, ApiMode};
 use crate::errors::classify_bus_error;
 use crate::reasoning::{is_reasoning_model, reasoning_effort_for};
 use crate::request::{build_body, build_headers, BodyArgs};
@@ -21,6 +21,23 @@ use tokio::sync::mpsc;
 /// Heartbeat cadence while the upstream is silent (spec: at least every 30s).
 pub const PING_INTERVAL: Duration = Duration::from_secs(30);
 
+fn compatible_reasoning_effort(
+    api_mode: ApiMode,
+    model: &str,
+    has_tools: bool,
+    effort: Option<&'static str>,
+) -> (Option<&'static str>, bool) {
+    let needs_luna_guard = api_mode == ApiMode::ChatCompletions
+        && has_tools
+        && model.to_ascii_lowercase().contains("luna")
+        && effort != Some("none");
+    if needs_luna_guard {
+        (Some("none"), true)
+    } else {
+        (effort, false)
+    }
+}
+
 pub fn make_stream(
     iii: IIIClient,
     http: reqwest::Client,
@@ -86,7 +103,7 @@ async fn run_stream_call(
         Some(m) => Some(m),
         None => router_client::models_get(iii, &model).await,
     };
-    let reasoning_effort = if is_reasoning_model(
+    let mut reasoning_effort = if is_reasoning_model(
         &model,
         model_meta.as_ref().and_then(|m| m.supports_thinking),
     ) {
@@ -108,15 +125,28 @@ async fn run_stream_call(
         None
     };
 
-    let body = build_body(&BodyArgs {
-        model: cfg.model.clone(),
-        max_tokens: cfg.max_tokens,
-        system_prompt: input.system_prompt.unwrap_or_default(),
-        messages: input.messages,
-        tools: input.tools.unwrap_or_default(),
-        reasoning_effort,
-        response_format: input.response_format,
-    });
+    let tools = input.tools.unwrap_or_default();
+    let (compatible_effort, effort_was_disabled) =
+        compatible_reasoning_effort(cfg.api_mode, &model, !tools.is_empty(), reasoning_effort);
+    reasoning_effort = compatible_effort;
+    if effort_was_disabled {
+        warnings.push(format!(
+            "reasoning effort disabled: {model} does not support function tools with reasoning_effort on Chat Completions"
+        ));
+    }
+
+    let body = build_body(
+        &BodyArgs {
+            model: cfg.model.clone(),
+            max_tokens: cfg.max_tokens,
+            system_prompt: input.system_prompt.unwrap_or_default(),
+            messages: input.messages,
+            tools,
+            reasoning_effort,
+            response_format: input.response_format,
+        },
+        cfg.api_mode,
+    );
     let headers = build_headers(&cfg);
 
     let rx = spawn_upstream(
@@ -180,6 +210,32 @@ mod tests {
         }
     }
 
+    #[test]
+    fn luna_tools_disable_effort_only_on_chat_completions() {
+        assert_eq!(
+            compatible_reasoning_effort(
+                ApiMode::ChatCompletions,
+                "gpt-5.6-luna",
+                true,
+                Some("high")
+            ),
+            (Some("none"), true)
+        );
+        assert_eq!(
+            compatible_reasoning_effort(ApiMode::Responses, "gpt-5.6-luna", true, Some("high")),
+            (Some("high"), false)
+        );
+        assert_eq!(
+            compatible_reasoning_effort(
+                ApiMode::ChatCompletions,
+                "gpt-5.6-luna",
+                false,
+                Some("high")
+            ),
+            (Some("high"), false)
+        );
+    }
+
     #[tokio::test(flavor = "multi_thread")]
     async fn forwards_events_and_stops_at_terminal() {
         let ch = FakeChannel::new();
diff --git a/provider-openai/src/surface.rs b/provider-openai/src/surface.rs
index 2a1a004fd..534234a65 100644
--- a/provider-openai/src/surface.rs
+++ b/provider-openai/src/surface.rs
@@ -14,8 +14,9 @@ use llm_router::types::router::{
 };
 
 pub const STREAM_ID: &str = "provider::openai::stream";
-pub const STREAM_DESC: &str = "Stream an OpenAI chat completion: resolve credentials, call the \
-     upstream Chat Completions API, and relay AssistantMessageEvent frames to writer_ref.";
+pub const STREAM_DESC: &str =
+    "Stream an OpenAI response: resolve credentials, call the configured \
+     Responses or Chat Completions endpoint, and relay AssistantMessageEvent frames to writer_ref.";
 
 pub const REFRESH_MODELS_ID: &str = "provider::openai::refresh_models";
 pub const REFRESH_MODELS_DESC: &str = "Refresh the OpenAI catalog slice from GET /v1/models and \
diff --git a/provider-openai/src/upstream.rs b/provider-openai/src/upstream.rs
index aa6d0e8b4..fb5b06887 100644
--- a/provider-openai/src/upstream.rs
+++ b/provider-openai/src/upstream.rs
@@ -1,4 +1,5 @@
-//! POST /v1/chat/completions (stream:true) → SSE → mpsc<AssistantMessageEvent>.
+//! POST an OpenAI Responses or Chat Completions stream → SSE →
+//! mpsc<AssistantMessageEvent>.
 //! The receiver dropping aborts the upstream: every send error returns,
 //! which drops the reqwest response mid-body and closes the connection.
 use crate::errors::classify;
@@ -155,12 +156,23 @@ async fn run_upstream(
             }
         }
     }
-    // Stream ended without [DONE] (connection close framing): still terminal.
-    let _ = tx
-        .send(AssistantMessageEvent::Done {
-            message: build_final(&state, &args.model),
-        })
-        .await;
+    // Responses usually terminates with `response.completed`; compatible
+    // gateways may instead close the connection after their final delta.
+    if state.has_content() {
+        let _ = tx
+            .send(AssistantMessageEvent::Done {
+                message: build_final(&state, &args.model),
+            })
+            .await;
+    } else {
+        let _ = tx
+            .send(synthetic_error_event(
+                "openai stream ended without output or a completion event",
+                &args.model,
+                ErrorKind::Transient,
+            ))
+            .await;
+    }
 }
 
 #[cfg(test)]
@@ -204,6 +216,8 @@ mod tests {
 
     const HAPPY: &str = "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\nconnection: close\r\n\r\ndata: {\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"}}]}\n\ndata: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hello\"}}]}\n\ndata: {\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}]}\n\ndata: {\"choices\":[],\"usage\":{\"prompt_tokens\":12,\"completion_tokens\":2,\"prompt_tokens_details\":{\"cached_tokens\":4}}}\n\ndata: [DONE]\n\n";
 
+    const RESPONSES_HAPPY: &str = "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\nconnection: close\r\n\r\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"Hello\"}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"usage\":{\"input_tokens\":12,\"output_tokens\":2}}}\n\n";
+
     #[tokio::test(flavor = "multi_thread")]
     async fn happy_stream_yields_start_through_stop_and_done() {
         let url = stub(HAPPY).await;
@@ -235,6 +249,30 @@ mod tests {
         assert_eq!(events.iter().filter(|e| e.is_terminal()).count(), 1);
     }
 
+    #[tokio::test(flavor = "multi_thread")]
+    async fn responses_stream_yields_start_through_stop_and_done() {
+        let url = stub(RESPONSES_HAPPY).await;
+        let events = drain(spawn_upstream(reqwest::Client::new(), args(url))).await;
+        assert!(matches!(
+            events.first(),
+            Some(AssistantMessageEvent::Start { .. })
+        ));
+        assert!(matches!(
+            events[events.len() - 2],
+            AssistantMessageEvent::Stop { .. }
+        ));
+        match events.last() {
+            Some(AssistantMessageEvent::Done { message }) => {
+                assert!(
+                    matches!(&message.content[0], llm_router::types::content::ContentBlock::Text { text } if text == "Hello")
+                );
+                assert_eq!(message.usage.as_ref().unwrap().input, Some(12));
+            }
+            other => panic!("want done, got {other:?}"),
+        }
+        assert_eq!(events.iter().filter(|e| e.is_terminal()).count(), 1);
+    }
+
     #[tokio::test(flavor = "multi_thread")]
     async fn http_401_yields_auth_expired_error_frame() {
         let url = stub(
diff --git a/provider-openai/src/wire/messages.rs b/provider-openai/src/wire/messages.rs
index bcd35e013..b338bf97e 100644
--- a/provider-openai/src/wire/messages.rs
+++ b/provider-openai/src/wire/messages.rs
@@ -247,6 +247,175 @@ pub fn to_wire_messages(messages: &[AgentMessage], system_prompt: &str) -> Vec<V
     out
 }
 
+fn responses_user_content_parts(content: &[ContentBlock]) -> Vec<Value> {
+    let mut parts = Vec::new();
+    let text = content
+        .iter()
+        .filter_map(|block| match block {
+            ContentBlock::Text { text } => Some(text.as_str()),
+            _ => None,
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    if !text.is_empty() {
+        parts.push(json!({ "type": "input_text", "text": text }));
+    }
+    for block in content {
+        if let ContentBlock::Image { mime, data } = block {
+            parts.push(json!({
+                "type": "input_image",
+                "image_url": format!("data:{mime};base64,{data}")
+            }));
+        }
+    }
+    if parts.is_empty() {
+        parts.push(json!({ "type": "input_text", "text": "" }));
+    }
+    parts
+}
+
+fn responses_function_call_output(call_id: &str, output: String) -> Value {
+    json!({ "type": "function_call_output", "call_id": call_id, "output": output })
+}
+
+fn flush_responses_result_images(out: &mut Vec<Value>, buf: &mut Vec<(String, Vec<Value>)>) {
+    if buf.is_empty() {
+        return;
+    }
+    let mut parts = Vec::new();
+    for (call_id, images) in buf.drain(..) {
+        parts.push(json!({
+            "type": "input_text",
+            "text": format!("[image result of tool call {call_id}]")
+        }));
+        parts.extend(images);
+    }
+    out.push(json!({ "role": "user", "content": parts }));
+}
+
+fn upsert_responses_output(out: &mut Vec<Value>, row: Value) {
+    let id = row.get("call_id").and_then(Value::as_str).unwrap_or("");
+    let existing = out.iter().position(|entry| {
+        entry.get("type").and_then(Value::as_str) == Some("function_call_output")
+            && entry.get("call_id").and_then(Value::as_str) == Some(id)
+    });
+    match existing {
+        Some(index) => out[index] = row,
+        None => out.push(row),
+    }
+}
+
+/// Build a stateless Responses `input` item array. Function calls and results
+/// are distinct items correlated by `call_id`; incomplete calls receive a
+/// synthetic output so a damaged transcript remains replayable.
+pub fn to_responses_input(messages: &[AgentMessage], system_prompt: &str) -> Vec<Value> {
+    let messages = llm_router::types::messages::reorder_displaced_results(messages);
+    let mut out = Vec::new();
+    if !system_prompt.is_empty() {
+        out.push(json!({
+            "role": "system",
+            "content": [{ "type": "input_text", "text": system_prompt }],
+        }));
+    }
+
+    let mut resolved_ids: HashSet<String> = messages
+        .iter()
+        .filter_map(|message| match message {
+            AgentMessage::FunctionResult(result) => Some(result.function_call_id.clone()),
+            _ => None,
+        })
+        .collect();
+    let mut image_buf: Vec<(String, Vec<Value>)> = Vec::new();
+
+    for message in messages {
+        match message {
+            AgentMessage::User(user) => {
+                flush_responses_result_images(&mut out, &mut image_buf);
+                out.push(json!({
+                    "role": "user",
+                    "content": responses_user_content_parts(&user.content)
+                }));
+            }
+            AgentMessage::Assistant(assistant) => {
+                flush_responses_result_images(&mut out, &mut image_buf);
+                let text = assistant
+                    .content
+                    .iter()
+                    .filter_map(|block| match block {
+                        ContentBlock::Text { text } => Some(text.as_str()),
+                        _ => None,
+                    })
+                    .collect::<Vec<_>>()
+                    .join("\n");
+                if !text.is_empty() {
+                    out.push(json!({
+                        "role": "assistant",
+                        "content": [{ "type": "output_text", "text": text }],
+                    }));
+                }
+                for block in &assistant.content {
+                    if let ContentBlock::FunctionCall {
+                        id,
+                        function_id,
+                        arguments,
+                    } = block
+                    {
+                        out.push(json!({
+                            "type": "function_call",
+                            "call_id": id,
+                            "name": encode_tool_name(function_id),
+                            "arguments": arguments.to_string(),
+                        }));
+                        if !resolved_ids.contains(id) {
+                            out.push(responses_function_call_output(
+                                id,
+                                ORPHAN_TOOL_PLACEHOLDER.to_string(),
+                            ));
+                            resolved_ids.insert(id.clone());
+                        }
+                    }
+                }
+            }
+            AgentMessage::FunctionResult(result) => {
+                upsert_responses_output(
+                    &mut out,
+                    responses_function_call_output(
+                        &result.function_call_id,
+                        format_function_result_content(result),
+                    ),
+                );
+                let images: Vec<Value> = result
+                    .content
+                    .iter()
+                    .filter_map(|block| match block {
+                        ContentBlock::Image { mime, data } => Some(json!({
+                            "type": "input_image",
+                            "image_url": format!("data:{mime};base64,{data}")
+                        })),
+                        _ => None,
+                    })
+                    .collect();
+                let existing = image_buf
+                    .iter()
+                    .position(|(id, _)| id == &result.function_call_id);
+                match existing {
+                    Some(index) if images.is_empty() => {
+                        image_buf.remove(index);
+                    }
+                    Some(index) => image_buf[index].1 = images,
+                    None if !images.is_empty() => {
+                        image_buf.push((result.function_call_id.clone(), images));
+                    }
+                    None => {}
+                }
+            }
+            AgentMessage::Custom(_) => {}
+        }
+    }
+    flush_responses_result_images(&mut out, &mut image_buf);
+    out
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -618,4 +787,25 @@ mod tests {
         );
         assert!(wire.is_empty(), "thinking-only assistant omitted: {wire:?}");
     }
+
+    #[test]
+    fn responses_replays_calls_and_outputs_as_items() {
+        let wire = to_responses_input(
+            &[
+                assistant(vec![ContentBlock::Text { text: "run".into() }, call("t1")]),
+                result("t1", "ok", json!({})),
+            ],
+            "be brief",
+        );
+        assert_eq!(wire[0]["role"], "system");
+        assert_eq!(wire[0]["content"][0]["type"], "input_text");
+        assert_eq!(wire[1]["role"], "assistant");
+        assert_eq!(wire[1]["content"][0]["type"], "output_text");
+        assert_eq!(wire[2]["type"], "function_call");
+        assert_eq!(wire[2]["call_id"], "t1");
+        assert_eq!(wire[2]["name"], "shell__exec");
+        assert_eq!(wire[3]["type"], "function_call_output");
+        assert_eq!(wire[3]["call_id"], "t1");
+        assert_eq!(wire[3]["output"], "ok");
+    }
 }
diff --git a/provider-openai/src/wire/mod.rs b/provider-openai/src/wire/mod.rs
index 40a7428a1..ca1fa52f4 100644
--- a/provider-openai/src/wire/mod.rs
+++ b/provider-openai/src/wire/mod.rs
@@ -1,4 +1,4 @@
-//! AgentMessage/AgentFunction → OpenAI Chat Completions wire shapes.
+//! AgentMessage/AgentFunction → OpenAI Responses and Chat Completions shapes.
 pub mod messages;
 pub mod names;
 pub mod tools;
diff --git a/provider-openai/src/wire/tools.rs b/provider-openai/src/wire/tools.rs
index 21b46cbbc..1e00a4d5f 100644
--- a/provider-openai/src/wire/tools.rs
+++ b/provider-openai/src/wire/tools.rs
@@ -19,6 +19,22 @@ pub fn functions_to_wire(tools: &[AgentFunction]) -> Vec<Value> {
         .collect()
 }
 
+/// Responses uses the same function definition fields without the nested
+/// `function` envelope used by Chat Completions.
+pub fn functions_to_responses_wire(tools: &[AgentFunction]) -> Vec<Value> {
+    tools
+        .iter()
+        .map(|tool| {
+            json!({
+                "type": "function",
+                "name": encode_tool_name(&tool.name),
+                "description": tool.description,
+                "parameters": tool.parameters,
+            })
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -47,5 +63,21 @@ mod tests {
     #[test]
     fn empty_input_yields_empty_array() {
         assert!(functions_to_wire(&[]).is_empty());
+        assert!(functions_to_responses_wire(&[]).is_empty());
+    }
+
+    #[test]
+    fn responses_shape_has_flat_function_fields() {
+        let tools = vec![AgentFunction {
+            name: "agent::trigger".into(),
+            description: "Invoke an iii function".into(),
+            parameters: json!({ "type": "object" }),
+            label: None,
+            execution_mode: None,
+        }];
+        let wire = functions_to_responses_wire(&tools);
+        assert_eq!(wire[0]["type"], "function");
+        assert_eq!(wire[0]["name"], "agent__trigger");
+        assert!(wire[0].get("function").is_none());
     }
 }
diff --git a/provider-openai/tests/golden/schemas/provider.openai.stream.json b/provider-openai/tests/golden/schemas/provider.openai.stream.json
index 57843671b..e34599586 100644
--- a/provider-openai/tests/golden/schemas/provider.openai.stream.json
+++ b/provider-openai/tests/golden/schemas/provider.openai.stream.json
@@ -1,5 +1,5 @@
 {
-  "description": "Stream an OpenAI chat completion: resolve credentials, call the upstream Chat Completions API, and relay AssistantMessageEvent frames to writer_ref.",
+  "description": "Stream an OpenAI response: resolve credentials, call the configured Responses or Chat Completions endpoint, and relay AssistantMessageEvent frames to writer_ref.",
   "function_id": "provider::openai::stream",
   "request_schema": {
     "$schema": "http://json-schema.org/draft-07/schema#",
@@ -419,6 +419,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -508,6 +517,24 @@
         },
         "type": "object"
       },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
+      },
       "ResponseFormat": {
         "properties": {
           "schema": true,
diff --git a/provider-openai/tests/integration.rs b/provider-openai/tests/integration.rs
index 02edde853..df505d5d3 100644
--- a/provider-openai/tests/integration.rs
+++ b/provider-openai/tests/integration.rs
@@ -182,7 +182,7 @@ async fn consumer_channel(
 
 /// Routes by request line; loops over connections until dropped.
 struct StubUpstream {
-    url: String, // http://addr/v1/chat/completions — what goes in the config slice
+    url: String, // generation endpoint written into the router config slice
     handle: tokio::task::JoinHandle<()>,
 }
 
@@ -194,11 +194,17 @@ impl Drop for StubUpstream {
 
 const STUB_SSE: &str = "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\nconnection: close\r\n\r\ndata: {\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"}}]}\n\ndata: {\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hello\"}}]}\n\ndata: {\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}]}\n\ndata: {\"choices\":[],\"usage\":{\"prompt_tokens\":12,\"completion_tokens\":2,\"prompt_tokens_details\":{\"cached_tokens\":4}}}\n\ndata: [DONE]\n\n";
 
+const STUB_RESPONSES_SSE: &str = "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\nconnection: close\r\n\r\ndata: {\"type\":\"response.output_text.delta\",\"delta\":\"Hello from Responses\"}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"usage\":{\"input_tokens\":12,\"output_tokens\":3}}}\n\n";
+
 const STUB_401: &str = "HTTP/1.1 401 Unauthorized\r\ncontent-type: application/json\r\nconnection: close\r\n\r\n{\"error\":{\"message\":\"Incorrect API key provided.\",\"type\":\"invalid_request_error\",\"code\":\"invalid_api_key\"}}";
 
 const STUB_MODELS: &str = "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\nconnection: close\r\n\r\n{\"data\":[{\"id\":\"gpt-5.2\",\"object\":\"model\"},{\"id\":\"gpt-5.2-2025-12-11\",\"object\":\"model\"},{\"id\":\"gpt-5.4-2026-03-05\",\"object\":\"model\"},{\"id\":\"o3-mini\",\"object\":\"model\"},{\"id\":\"text-embedding-3-large\",\"object\":\"model\"}]}";
 
 async fn stub_upstream(messages_response: &'static str) -> StubUpstream {
+    stub_upstream_at(messages_response, "/v1/chat/completions").await
+}
+
+async fn stub_upstream_at(messages_response: &'static str, endpoint: &str) -> StubUpstream {
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
     let addr = listener.local_addr().unwrap();
@@ -222,7 +228,7 @@ async fn stub_upstream(messages_response: &'static str) -> StubUpstream {
         }
     });
     StubUpstream {
-        url: format!("http://{addr}/v1/chat/completions"),
+        url: format!("http://{addr}{endpoint}"),
         handle,
     }
 }
@@ -394,6 +400,52 @@ async fn chat_streams_end_to_end_with_cost_fill() {
     provider_iii.shutdown();
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn responses_streams_end_to_end() {
+    let engine = engine_or_skip!();
+    let stub = stub_upstream_at(STUB_RESPONSES_SSE, "/v1/responses").await;
+    let (router_iii, provider_iii) = boot_stack(&engine.url).await;
+    configure_stub_key(&router_iii, &stub.url).await;
+    refresh_and_wait(&router_iii, &provider_iii, "gpt-5.2").await;
+
+    let consumer = register_worker(&engine.url, InitOptions::default());
+    let (writer_ref, frames, pump) = consumer_channel(&consumer).await;
+    let response = consumer
+        .trigger(TriggerRequest {
+            function_id: "router::chat".into(),
+            payload: json!({
+                "writer_ref": writer_ref,
+                "model": "gpt-5.2",
+                "messages": [{
+                    "role": "user",
+                    "content": [{ "type": "text", "text": "hi" }],
+                    "timestamp": 1
+                }],
+            }),
+            action: None,
+            timeout_ms: Some(30_000),
+        })
+        .await
+        .expect("Responses chat succeeds");
+    assert_eq!(response["ok"], true, "chat response: {response}");
+    assert_eq!(response["provider"], "openai");
+    assert_eq!(response["stop_reason"], "end");
+
+    let _ = tokio::time::timeout(Duration::from_secs(5), pump).await;
+    let frames = frames.lock().unwrap();
+    let last: Value = serde_json::from_str(frames.last().unwrap()).unwrap();
+    assert_eq!(last["type"], "done");
+    assert_eq!(
+        last["message"]["content"][0]["text"],
+        "Hello from Responses"
+    );
+    assert_eq!(last["message"]["usage"]["input"], 12);
+
+    consumer.shutdown();
+    router_iii.shutdown();
+    provider_iii.shutdown();
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn upstream_401_surfaces_as_auth_expired_error_frame() {
     let engine = engine_or_skip!();
diff --git a/provider-xai/src/curated.rs b/provider-xai/src/curated.rs
index 46b032d33..223deb429 100644
--- a/provider-xai/src/curated.rs
+++ b/provider-xai/src/curated.rs
@@ -99,6 +99,7 @@ pub fn enrich(id: &str) -> Model {
             input_limit: None,
             supports_thinking: Some(reasoning),
             supports_xhigh: Some(supports_xhigh),
+            reasoning_efforts: None,
             supports_tools: Some(true),
             supports_vision: Some(vision),
             supports_cache: Some(true),
@@ -115,6 +116,7 @@ pub fn enrich(id: &str) -> Model {
             input_limit: None,
             supports_thinking: None,
             supports_xhigh: None,
+            reasoning_efforts: None,
             supports_tools: Some(true),
             supports_vision: None,
             supports_cache: Some(true),
diff --git a/provider-xai/tests/golden/schemas/provider.xai.stream.json b/provider-xai/tests/golden/schemas/provider.xai.stream.json
index ce6ec1cad..740b0758b 100644
--- a/provider-xai/tests/golden/schemas/provider.xai.stream.json
+++ b/provider-xai/tests/golden/schemas/provider.xai.stream.json
@@ -419,6 +419,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -508,6 +517,24 @@
         },
         "type": "object"
       },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
+      },
       "ResponseFormat": {
         "properties": {
           "schema": true,
diff --git a/provider-zai/src/curated.rs b/provider-zai/src/curated.rs
index a8b4c3d4d..263717fd4 100644
--- a/provider-zai/src/curated.rs
+++ b/provider-zai/src/curated.rs
@@ -195,6 +195,7 @@ fn to_model(r: &Row) -> Model {
         supports_thinking: Some(true),
         // `reasoning_effort: xhigh` exists on GLM-5.2+ only.
         supports_xhigh: Some(r.id.starts_with("glm-5.2")),
+        reasoning_efforts: None,
         supports_tools: Some(true),
         supports_vision: Some(r.vision),
         // Implicit prompt caching, billed at the cached-input rate.
diff --git a/provider-zai/tests/golden/schemas/provider.zai.stream.json b/provider-zai/tests/golden/schemas/provider.zai.stream.json
index b9d846a66..949921615 100644
--- a/provider-zai/tests/golden/schemas/provider.zai.stream.json
+++ b/provider-zai/tests/golden/schemas/provider.zai.stream.json
@@ -419,6 +419,15 @@
           "provider": {
             "type": "string"
           },
+          "reasoning_efforts": {
+            "items": {
+              "$ref": "#/definitions/ReasoningEffort"
+            },
+            "type": [
+              "array",
+              "null"
+            ]
+          },
           "supports_cache": {
             "type": [
               "boolean",
@@ -508,6 +517,24 @@
         },
         "type": "object"
       },
+      "ReasoningEffort": {
+        "description": "One provider-native reasoning effort advertised for a specific model.\n\nValues intentionally remain strings: provider catalogs can add efforts without requiring a router-wide enum release first.",
+        "properties": {
+          "description": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "effort": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "effort"
+        ],
+        "type": "object"
+      },
       "ResponseFormat": {
         "properties": {
           "schema": true,
diff --git a/tech-specs/2026-06-agentic/README.md b/tech-specs/2026-06-agentic/README.md
index 28b0227a7..111ff8520 100644
--- a/tech-specs/2026-06-agentic/README.md
+++ b/tech-specs/2026-06-agentic/README.md
@@ -373,6 +373,11 @@ The capability record `llm-router` serves and every worker reads to make budget/
 // levels map to provider-native knobs via Model.thinking_budgets.
 type ThinkingLevel = "minimal" | "low" | "medium" | "high" | "xhigh";
 
+type ReasoningEffort = {
+  effort: string;             // provider-native value, e.g. "xhigh" or "ultra"
+  description?: string;       // provider-supplied picker guidance
+};
+
 type Capability =
   | "thinking" | "thinking:low" | "thinking:medium" | "thinking:high" | "thinking:xhigh"
   | "tools" | "vision" | "cache" | "structured_output";
@@ -386,6 +391,7 @@ type Model = {
   input_limit?: number;       // usable input budget if distinct from context_window
   supports_thinking?: boolean;
   supports_xhigh?: boolean;
+  reasoning_efforts?: ReasoningEffort[];
   supports_tools?: boolean;
   supports_vision?: boolean;
   supports_cache?: boolean;
diff --git a/tech-specs/2026-06-agentic/llm-router.md b/tech-specs/2026-06-agentic/llm-router.md
index c8867c338..93918d875 100644
--- a/tech-specs/2026-06-agentic/llm-router.md
+++ b/tech-specs/2026-06-agentic/llm-router.md
@@ -552,6 +552,10 @@ strings, each mapping to a field on `Model`:
   a budget tier (mapped to the provider's native knob; see `thinking_budgets`).
 - `thinking:xhigh` -> `supports_xhigh` — the model supports the extra-high reasoning tier specifically
   (a separate flag because not every thinking-capable model offers it).
+- `reasoning_efforts` carries the exact provider-native effort values advertised for a model, plus
+  optional descriptions for picker UX. Consumers should use this list when present instead of
+  assuming the generic `ThinkingLevel` ladder. Native overrides travel through the namespaced
+  `provider_options` field on `router::chat`.
 
 Unknown strings return `{ supported: false }` and match no models.