diff --git a/src/main/ipc/validation.ts b/src/main/ipc/validation.ts
index 8c1ea84..52ae433 100644
--- a/src/main/ipc/validation.ts
+++ b/src/main/ipc/validation.ts
@@ -93,7 +93,9 @@ export const ConnectionSchemas = {
       protocol: z.enum(API_PROTOCOLS),
       baseUrl: z.string().min(1, 'Base URL 不能为空'),
       apiKey: z.string(),
-      modelId: z.string().min(1, 'Model ID 不能为空')
+      modelId: z.string().min(1, 'Model ID 不能为空'),
+      // Absent means "no ceiling": the provider's own default applies (#150).
+      maxOutputTokens: z.number().int().positive().optional()
     })
   }),
 
diff --git a/src/main/models/ModelClient.ts b/src/main/models/ModelClient.ts
index f37cca0..b876ba3 100644
--- a/src/main/models/ModelClient.ts
+++ b/src/main/models/ModelClient.ts
@@ -15,7 +15,6 @@ import type { EmbeddingConfig, EmbeddingResult } from './types'
 import Logger from '../../shared/utils/logger'
 
 const DEFAULT_TEMPERATURE = 0.7
-const DEFAULT_MAX_TOKENS = 2048
 
 /**
  * One provider call, as a stream.
@@ -93,11 +92,16 @@ export class ModelClient {
   streamChat(messages: APIMessage[], options: { signal?: AbortSignal } = {}): ChatStream {
     Logger.debug('ModelClient', `Streaming with model: ${this.connection.modelId}`)
 
+    const maxOutputTokens = this.connection.maxOutputTokens
+
     const result = streamText({
       model: this.getAIModel(),
       messages: convertToCoreMessages(messages),
       temperature: DEFAULT_TEMPERATURE,
-      maxOutputTokens: DEFAULT_MAX_TOKENS,
+      // Only when the connection asks for a ceiling. Absent means the model's own
+      // default, which is what a reasoning model needs: its thinking shares this
+      // budget with the answer, so 2048 of them was a ceiling reached early (#150).
+      ...(maxOutputTokens !== undefined && { maxOutputTokens }),
       // Owned by the caller, so that stopping a turn actually cancels the provider
       // request rather than only recording that it was stopped.
       abortSignal: options.signal
diff --git a/src/main/services/chat/ChatExecution.ts b/src/main/services/chat/ChatExecution.ts
index e1848ea..cfa6c9d 100644
--- a/src/main/services/chat/ChatExecution.ts
+++ b/src/main/services/chat/ChatExecution.ts
@@ -36,7 +36,13 @@ export class ChatExecution {
 
   private currentStatus: ChatExecutionStatus = 'pending'
   private settledOutcome: ChatExecutionOutcome | undefined
-  private readonly controller = new AbortController()
+  /**
+   * The attempt in flight.
+   *
+   * Replaced by `beginAttempt`, because a retry must not inherit a signal that a
+   * timeout or a cancel has already aborted (#150).
+   */
+  private attemptController = new AbortController()
 
   constructor(init: { id: string; messageId: string; sessionId: string; notebookId?: string }) {
     this.id = init.id
@@ -60,9 +66,31 @@ export class ChatExecution {
     return this.settledOutcome !== undefined
   }
 
-  /** Handed to the provider call, so a stop cancels the request itself. */
+  /** The signal of the attempt in flight. */
   get signal(): AbortSignal {
-    return this.controller.signal
+    return this.attemptController.signal
+  }
+
+  /**
+   * Open a fresh attempt, and hand back the signal that cancels it.
+   *
+   * Called before every provider call, including a retry: the previous attempt's
+   * signal is spent.
+   */
+  beginAttempt(): AbortSignal {
+    this.attemptController = new AbortController()
+    return this.attemptController.signal
+  }
+
+  /**
+   * Cancel the attempt in flight without deciding anything about the turn.
+   *
+   * The idle deadline uses this: stopping a request that has gone quiet is not a
+   * statement about what the turn was, and the attempt that was cancelled reports
+   * back as a failure the retry policy can look at (#150).
+   */
+  cancel(): void {
+    this.attemptController.abort()
   }
 
   /** The first chunk, which is what turns "waiting" into "streaming". */
@@ -95,7 +123,7 @@ export class ChatExecution {
     const settled = this.settle(abortedOutcome(reason))
     if (!settled) return null
 
-    this.controller.abort()
+    this.attemptController.abort()
     return settled
   }
 }
diff --git a/src/main/services/chat/ChatStreamManager.ts b/src/main/services/chat/ChatStreamManager.ts
index 7df6e41..57215af 100644
--- a/src/main/services/chat/ChatStreamManager.ts
+++ b/src/main/services/chat/ChatStreamManager.ts
@@ -12,7 +12,13 @@ import type {
 import type { Citation, CitationContext } from '../../../shared/types/citation'
 import { classifyTerminal, failedOutcome } from '../../../shared/utils/chatExecution'
 import { resolveCitations } from '../../../shared/utils/citationResolution'
-import { isTerminalChunk, messageReasoning, messageText } from '../../../shared/utils/uiMessage'
+import {
+  carriesContent,
+  isTerminalChunk,
+  messageReasoning,
+  messageText
+} from '../../../shared/utils/uiMessage'
+import { retryDelayMs, shouldRetry } from './retryPolicy'
 import { estimateTokens } from '../../../shared/utils/tokenEstimate'
 import Logger from '../../../shared/utils/logger'
 import { ChatExecution } from './ChatExecution'
@@ -58,6 +64,18 @@ import type { SessionAutoSwitchService } from '../SessionAutoSwitchService'
  *   was stopped.
  */
 
+/**
+ * How long a turn may produce nothing before its request is cancelled.
+ *
+ * Generous on purpose: this is for a stream that has died, not for a model that is
+ * slow to start. Every event resets it, so a reasoning model is never cut off
+ * mid-thought (#150).
+ */
+const IDLE_TIMEOUT_MS = 60_000
+
+/** Waits before the next attempt. */
+const wait = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))
+
 /** What the turn's persistence needs, as a port: see `turnStore.ts`. */
 export interface ChatTurnStore {
   createTurn(sessionId: string): { id: string }
@@ -100,6 +118,19 @@ interface TurnEntry {
   usage?: ChatTokenUsage
   /** The message of an `error` chunk, when the provider reported one mid-stream. */
   streamError?: string
+  /**
+   * Whether anything the reader would see has been forwarded.
+   *
+   * Sticky across attempts on purpose: once content has been sent, no later attempt
+   * may be started, whatever the failure (#150).
+   */
+  contentSent?: boolean
+  /** Set when the idle deadline cancelled the attempt, so its failure reads as one. */
+  timedOut?: boolean
+  /** The attempt in flight, 1-based; logged, and what the retry bound counts. */
+  attempts?: number
+  /** The watchdog for the attempt in flight. */
+  idle?: { reset: () => void; stop: () => void }
   /** Monotonic per execution, so a consumer can detect a gap. */
   seq: number
 }
@@ -112,6 +143,8 @@ export class ChatStreamManager {
     private readonly deps: {
       store: ChatTurnStore
       sessionAutoSwitchService: Pick<SessionAutoSwitchService, 'recordTokenUsageAndCheckSwitch'>
+      /** Overridable so a test does not have to wait a minute to see the deadline. */
+      idleTimeoutMs?: number
     }
   ) {}
 
@@ -199,40 +232,134 @@ export class ChatStreamManager {
     return executionId === undefined ? undefined : this.turns.get(executionId)
   }
 
+  /**
+   * Run the turn, attempting it again while the retry policy says so (#150).
+   *
+   * Each attempt is a fresh provider call with its own signal. A retry is only
+   * reachable while nothing has reached the reader, so the answer on screen is never
+   * duplicated or silently replaced by a second attempt.
+   */
   private async run(entry: TurnEntry): Promise<void> {
+    for (let attempt = 1; ; attempt += 1) {
+      entry.attempts = attempt
+      const outcome = await this.attempt(entry)
+
+      // A stop the reader asked for has already settled the turn.
+      if (entry.execution.isSettled) return
+
+      if (shouldRetry({ outcome, attempt, contentSent: entry.contentSent === true })) {
+        const delay = retryDelayMs(attempt + 1)
+        Logger.warn(
+          'ChatStreamManager',
+          `Turn ${entry.execution.id} attempt ${attempt} failed (${outcome.status}${
+            outcome.status === 'failed' ? `: ${outcome.error.message}` : ''
+          }); retrying in ${delay}ms`
+        )
+        await wait(delay)
+        if (entry.execution.isSettled) return
+        continue
+      }
+
+      this.settleTurn(entry, outcome)
+      return
+    }
+  }
+
+  /**
+   * One provider call, from opening the attempt to its outcome.
+   *
+   * Nothing is settled here: a failure is a value the retry policy looks at, and the
+   * turn ends only once that policy has had its say.
+   */
+  private async attempt(entry: TurnEntry): Promise<ChatExecutionOutcome> {
     const { execution, request } = entry
     const client = request.client
-    if (!client) return
+    if (!client) {
+      return failedOutcome('Chat model not configured, please configure in settings', 'error')
+    }
 
+    // Per-attempt facts, cleared so a retry cannot inherit the previous attempt's.
+    entry.message = undefined
+    entry.finishReason = undefined
+    entry.usage = undefined
+    entry.streamError = undefined
+    entry.timedOut = false
+
+    const signal = execution.beginAttempt()
+    entry.idle = this.watchIdle(entry)
+
+    let outcome: ChatExecutionOutcome
     try {
-      const { events } = client.streamChat(request.messages, { signal: execution.signal })
+      const { events } = client.streamChat(request.messages, { signal })
       const [toRenderer, toAssemble] = events.tee()
-
-      await Promise.all([
-        this.forward(entry, toRenderer),
-        // The SDK assembles, and nothing here re-derives the message from deltas.
-        //
-        // Kept on the entry as each snapshot arrives rather than assigned once at the
-        // end: a turn can be stopped or fail while this branch is still running, and
-        // the part of the answer that had arrived is what gets persisted (#138
-        // invariant 5).
-        (async () => {
-          for await (const snapshot of readUIMessageStream({ stream: toAssemble })) {
-            entry.message = snapshot
-          }
-        })()
-      ])
+      await Promise.all([this.forward(entry, toRenderer), this.assemble(entry, toAssemble)])
+      // The stream ended without being stopped. What that means is
+      // `classifyTerminal`'s decision: a `finish` chunk's reason, or — when no
+      // terminal chunk arrived at all — an EOF, which is not success (#138
+      // invariant 1).
+      outcome = this.outcomeFor(entry)
     } catch (error) {
-      // A transport error arrives as a rejection rather than as an event. The
-      // partial answer is kept, and the turn ends as a failure.
-      this.settleTurn(entry, failedOutcome((error as Error).message, 'error'))
-      return
+      // A transport error arrives as a rejection: the partial answer is kept, and the
+      // failure is reported as the connection's.
+      outcome = failedOutcome((error as Error).message, 'error')
+    } finally {
+      entry.idle?.stop()
+      entry.idle = undefined
     }
 
-    // The stream ended without being stopped. What that means is `classifyTerminal`'s
-    // decision: a `finish` chunk's reason, or — when no terminal chunk arrived at all
-    // — an EOF, which is not success (#138 invariant 1).
-    this.settleTurn(entry, this.outcomeFor(entry))
+    // However the cancellation surfaced — a rejected read, or the SDK turning it into
+    // an `abort` chunk — the reason this attempt failed is the deadline that cancelled
+    // it (#150).
+    return entry.timedOut ? failedOutcome('The model stopped responding.', 'timeout') : outcome
+  }
+
+  /**
+   * The SDK assembles; nothing here re-derives the message from deltas.
+   *
+   * Kept on the entry as each snapshot arrives rather than assigned once at the end:
+   * a turn can be stopped or fail while this is still running, and the part of the
+   * answer that had arrived is what gets persisted (#138 invariant 5).
+   */
+  private async assemble(entry: TurnEntry, stream: ReadableStream<UIMessageChunk>): Promise<void> {
+    for await (const snapshot of readUIMessageStream({ stream })) {
+      entry.message = snapshot
+    }
+  }
+
+  /**
+   * The deadline for a stream that has gone quiet.
+   *
+   * Reset by every event — reasoning deltas included, so a model that thinks for a
+   * long time is not killed mid-thought. It *cancels* rather than settling: whether a
+   * silent provider is worth trying again is the retry policy's decision, not the
+   * watchdog's.
+   */
+  private watchIdle(entry: TurnEntry): { reset: () => void; stop: () => void } {
+    let timer: NodeJS.Timeout
+
+    const onIdle = (): void => {
+      if (entry.execution.isSettled) return
+      Logger.warn(
+        'ChatStreamManager',
+        `Turn ${entry.execution.id} produced nothing for ${this.deps.idleTimeoutMs ?? IDLE_TIMEOUT_MS}ms; cancelling the request`
+      )
+      entry.timedOut = true
+      entry.execution.cancel()
+    }
+
+    const arm = (): void => {
+      timer = setTimeout(onIdle, this.deps.idleTimeoutMs ?? IDLE_TIMEOUT_MS)
+    }
+
+    arm()
+
+    return {
+      reset: () => {
+        clearTimeout(timer)
+        arm()
+      },
+      stop: () => clearTimeout(timer)
+    }
   }
 
   /**
@@ -258,6 +385,9 @@ export class ChatStreamManager {
         }
 
         entry.execution.begin()
+        entry.idle?.reset()
+        if (carriesContent(value)) entry.contentSent = true
+
         entry.seq += 1
         entry.request.emit({
           type: 'chunk',
diff --git a/src/main/services/chat/retryPolicy.ts b/src/main/services/chat/retryPolicy.ts
new file mode 100644
index 0000000..9830797
--- /dev/null
+++ b/src/main/services/chat/retryPolicy.ts
@@ -0,0 +1,52 @@
+import type { ChatExecutionOutcome } from '../../../shared/types/chat'
+
+/**
+ * Whether a failed turn is worth attempting again (#150).
+ *
+ * The rule is deliberately narrow. A failure that is retried when it will fail the
+ * same way every time costs the reader time, tokens and a second wait for the same
+ * answer — so only failures that are recognisably transient are retried, and
+ * anything unrecognised is reported as it is.
+ *
+ * Two conditions beyond the kind of failure, both of which the caller supplies:
+ *
+ * - **nothing has been shown yet.** Once content has reached the reader, a retry
+ *   would either duplicate it or silently replace it.
+ * - **the attempts are bounded.** Backoff on top, so a provider that is down is not
+ *   hammered.
+ */
+
+/** How many attempts one turn may make, the first included. */
+export const MAX_ATTEMPTS = 3
+
+/** How long to wait before attempt `next` (1-based). */
+export const retryDelayMs = (next: number): number => 500 * 2 ** Math.max(0, next - 2)
+
+/**
+ * Failures that mean "try again", by the text the provider or transport gave us.
+ *
+ * A short list on purpose. Providers do not agree on error shapes and the UI event
+ * carries only a message, so this is a best-effort reading of what is transient —
+ * and the default is *not* to retry, which is the safe direction to be wrong in.
+ */
+const TRANSIENT =
+  /(rate.?limit|too many requests|\b429\b|\b50[0-9]\b|overloaded|temporarily unavailable|timeout|timed out|ECONNRESET|ECONNREFUSED|ECONNABORTED|ETIMEDOUT|EAI_AGAIN|EPIPE|socket hang up|premature close|fetch failed|network)/i
+
+export const isRetryableFailure = (outcome: ChatExecutionOutcome): boolean => {
+  if (outcome.status !== 'failed') return false
+
+  // A stream that went quiet and was cancelled, and a stream that ended without
+  // saying anything, are both the connection's fault rather than the request's.
+  if (outcome.reason === 'timeout' || outcome.reason === 'unexpected_eof') return true
+
+  return TRANSIENT.test(outcome.error.message)
+}
+
+export const shouldRetry = (options: {
+  outcome: ChatExecutionOutcome
+  /** The attempt that just failed, 1-based. */
+  attempt: number
+  /** Whether any content has reached the reader. */
+  contentSent: boolean
+}): boolean =>
+  options.attempt < MAX_ATTEMPTS && !options.contentSent && isRetryableFailure(options.outcome)
diff --git a/src/renderer/src/components/settings/ModelConnectionForm.tsx b/src/renderer/src/components/settings/ModelConnectionForm.tsx
index c26db89..179fe76 100644
--- a/src/renderer/src/components/settings/ModelConnectionForm.tsx
+++ b/src/renderer/src/components/settings/ModelConnectionForm.tsx
@@ -60,6 +60,12 @@ const EMPTY_CONNECTION: ModelConnection = {
   modelId: ''
 }
 
+/** A ceiling below 1 is not a ceiling; clearing the input means "automatic" (#150). */
+const toCeiling = (raw: string): number | undefined => {
+  const parsed = Number.parseInt(raw, 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined
+}
+
 export default function ModelConnectionForm({
   capability,
   connection,
@@ -286,6 +292,42 @@ export default function ModelConnectionForm({
         {fetchError && <p className="text-sm text-destructive">{fetchError}</p>}
       </div>
 
+      {/* Output ceiling. Chat only: an embedding connection has no output (#150). */}
+      {capability === 'chat' && (
+        <div className="flex flex-col gap-2">
+          <label className="text-sm font-medium text-foreground">{t('maxOutputTokens')}</label>
+          <Select
+            value={value.maxOutputTokens === undefined ? 'automatic' : 'custom'}
+            onValueChange={(mode) =>
+              update({
+                maxOutputTokens: mode === 'automatic' ? undefined : (value.maxOutputTokens ?? 8192)
+              })
+            }
+          >
+            <SelectTrigger className="w-full">
+              <SelectValue>
+                {value.maxOutputTokens === undefined
+                  ? t('maxOutputTokensAutomatic')
+                  : t('maxOutputTokensCustom')}
+              </SelectValue>
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="automatic">{t('maxOutputTokensAutomatic')}</SelectItem>
+              <SelectItem value="custom">{t('maxOutputTokensCustom')}</SelectItem>
+            </SelectContent>
+          </Select>
+          {value.maxOutputTokens !== undefined && (
+            <Input
+              type="number"
+              min={1}
+              value={String(value.maxOutputTokens)}
+              onChange={(e) => update({ maxOutputTokens: toCeiling(e.target.value) })}
+            />
+          )}
+          <p className="text-xs text-muted-foreground">{t('maxOutputTokensHint')}</p>
+        </div>
+      )}
+
       {/* Test connection */}
       <div className="flex items-center gap-3">
         <Button type="button" onClick={handleTest} disabled={testing} variant="outline" size="sm">
diff --git a/src/renderer/src/locales/en-US/settings.json b/src/renderer/src/locales/en-US/settings.json
index fdc5c43..e89032b 100644
--- a/src/renderer/src/locales/en-US/settings.json
+++ b/src/renderer/src/locales/en-US/settings.json
@@ -64,6 +64,10 @@
   "modelId": "Model ID",
   "modelIdPlaceholder": "e.g. gpt-4o-mini",
   "fetchModelsUnsupported": "This protocol does not expose a model list; enter the Model ID manually.",
+  "maxOutputTokens": "Max output tokens",
+  "maxOutputTokensAutomatic": "Automatic",
+  "maxOutputTokensCustom": "Custom",
+  "maxOutputTokensHint": "Automatic sends no limit and leaves it to the model. A reasoning model's thinking shares this budget with its answer.",
   "fetchModelsEmpty": "The endpoint returned no models; enter the Model ID manually.",
   "embeddingMode": "Embedding backend",
   "builtInLocal": "Built-in Local (recommended)",
diff --git a/src/renderer/src/locales/zh-CN/settings.json b/src/renderer/src/locales/zh-CN/settings.json
index b3d606b..982f97c 100644
--- a/src/renderer/src/locales/zh-CN/settings.json
+++ b/src/renderer/src/locales/zh-CN/settings.json
@@ -61,6 +61,10 @@
   "modelId": "Model ID",
   "modelIdPlaceholder": "例如 gpt-4o-mini",
   "fetchModelsUnsupported": "该协议不支持拉取模型列表，请手动填写 Model ID。",
+  "maxOutputTokens": "最大输出长度",
+  "maxOutputTokensAutomatic": "自动",
+  "maxOutputTokensCustom": "自定义",
+  "maxOutputTokensHint": "自动不发送上限，交给模型自己决定。推理模型的思考与正文共用这份预算。",
   "fetchModelsEmpty": "端点未返回任何模型，请手动填写 Model ID。",
   "embeddingMode": "嵌入后端",
   "builtInLocal": "内置本地（推荐）",
diff --git a/src/shared/types/chat.ts b/src/shared/types/chat.ts
index 5cf0589..5497950 100644
--- a/src/shared/types/chat.ts
+++ b/src/shared/types/chat.ts
@@ -93,7 +93,11 @@ export type ChatExecutionOutcome =
   | { status: 'truncated' }
   | { status: 'blocked' }
   | { status: 'aborted'; reason: 'user' | 'shutdown' }
-  | { status: 'failed'; error: ChatExecutionError; reason: 'error' | 'throw' | 'unexpected_eof' }
+  | {
+      status: 'failed'
+      error: ChatExecutionError
+      reason: 'error' | 'unexpected_eof' | 'timeout'
+    }
 
 /** Token accounting for one turn. Fields are optional because providers omit them. */
 export interface ChatTokenUsage {
diff --git a/src/shared/types/connection.ts b/src/shared/types/connection.ts
index 6c4d983..9a5614b 100644
--- a/src/shared/types/connection.ts
+++ b/src/shared/types/connection.ts
@@ -48,6 +48,14 @@ export interface ModelConnection {
   baseUrl: string
   apiKey: string
   modelId: string
+  /**
+   * The ceiling on generated tokens, or absent for the model's own default.
+   *
+   * Absent is the default on purpose: a reasoning model's thinking shares this
+   * budget with its answer, so a ceiling that is right for one model is wrong for
+   * another — per-connection, like the model id itself.
+   */
+  maxOutputTokens?: number
 }
 
 /**
diff --git a/src/shared/utils/chatExecution.ts b/src/shared/utils/chatExecution.ts
index 80d6c23..bd7cc47 100644
--- a/src/shared/utils/chatExecution.ts
+++ b/src/shared/utils/chatExecution.ts
@@ -60,7 +60,7 @@ export const classifyFinishReason = (finishReason: string): ChatExecutionOutcome
 /** A turn that ended because something went wrong, and where it went wrong. */
 export const failedOutcome = (
   message: string,
-  reason: 'error' | 'unexpected_eof'
+  reason: 'error' | 'unexpected_eof' | 'timeout'
 ): ChatExecutionOutcome => ({ status: 'failed', error: { message }, reason })
 
 /**
diff --git a/src/shared/utils/uiMessage.ts b/src/shared/utils/uiMessage.ts
index 46bf625..b802a90 100644
--- a/src/shared/utils/uiMessage.ts
+++ b/src/shared/utils/uiMessage.ts
@@ -52,6 +52,26 @@ export const collectMessageText = async (
 export const isReasoningLive = (message: UIMessage | undefined): boolean =>
   (message?.parts ?? []).some((part) => part.type === 'reasoning' && part.state === 'streaming')
 
+/**
+ * Whether a chunk carries something the reader would see.
+ *
+ * An allowlist of structural events rather than a list of content ones: anything the
+ * SDK adds later counts as content, which is the safe direction — a retry that
+ * should not have happened duplicates text, while one that should have and did not
+ * costs a wait (#150).
+ */
+const STRUCTURAL_CHUNKS = new Set<UIMessageChunk['type']>([
+  'start',
+  'start-step',
+  'finish-step',
+  'text-start',
+  'text-end',
+  'reasoning-start',
+  'reasoning-end'
+])
+
+export const carriesContent = (chunk: UIMessageChunk): boolean => !STRUCTURAL_CHUNKS.has(chunk.type)
+
 /**
  * The chunks that end a turn.
  *
diff --git a/test/chatStreamManager.test.ts b/test/chatStreamManager.test.ts
index dea75c8..772e508 100644
--- a/test/chatStreamManager.test.ts
+++ b/test/chatStreamManager.test.ts
@@ -7,6 +7,7 @@ import {
   ChatStreamManager,
   type ChatTurnStore
 } from '../src/main/services/chat/ChatStreamManager.ts'
+import { MAX_ATTEMPTS } from '../src/main/services/chat/retryPolicy.ts'
 import type {
   ChatExecutionOutcome,
   ChatMessageMetadata,
@@ -123,6 +124,85 @@ function erroringClient(text: string): ModelClient {
   return client
 }
 
+/**
+ * A provider whose first `failures` attempts die with `message`, and whose later
+ * attempts answer. Counts the calls, because "was it retried" is the point.
+ */
+function flakyClient(
+  failures: number,
+  message: string,
+  text: string
+): { client: ModelClient; calls: () => number } {
+  const model = new MockLanguageModelV2({
+    doStream: async () => {
+      const attempt = model.doStreamCalls.length
+      if (attempt <= failures) {
+        return {
+          stream: new ReadableStream({
+            async start(controller) {
+              controller.enqueue({ type: 'stream-start', warnings: [] })
+              await new Promise((resolve) => setTimeout(resolve, 5))
+              controller.error(new Error(message))
+            }
+          }) as never
+        }
+      }
+      return {
+        stream: simulateReadableStream({
+          chunks: [
+            { type: 'stream-start', warnings: [] },
+            ...textChunks(text),
+            finishChunk('stop')
+          ] as never[]
+        })
+      }
+    }
+  })
+  const client = new ModelClient('chat', connection)
+  client.getAIModel = () => model
+  return { client, calls: () => model.doStreamCalls.length }
+}
+
+/**
+ * A provider that sends an answer and then holds the connection open, which is what
+ * the idle deadline is for.
+ */
+function silentClient(text: string): { client: ModelClient; cancelled: () => boolean } {
+  let cancelled = false
+  const model = new MockLanguageModelV2({
+    doStream: async ({ abortSignal }) => ({
+      stream: new ReadableStream({
+        async start(controller) {
+          for (const chunk of [
+            { type: 'stream-start', warnings: [] },
+            ...textChunks(text)
+          ] as never[]) {
+            controller.enqueue(chunk)
+          }
+          await new Promise<void>((resolve) => {
+            if (!abortSignal || abortSignal.aborted) resolve()
+            else
+              abortSignal.addEventListener(
+                'abort',
+                () => {
+                  cancelled = true
+                  resolve()
+                },
+                { once: true }
+              )
+          })
+          // A real transport reports the cancellation by erroring the stream; a mock
+          // that just goes quiet would leave the reader waiting forever.
+          controller.error(new DOMException('The operation was aborted.', 'AbortError'))
+        }
+      }) as never
+    })
+  })
+  const client = new ModelClient('chat', connection)
+  client.getAIModel = () => model
+  return { client, cancelled: () => cancelled }
+}
+
 interface StoredTurn {
   messageId: string
   content?: string
@@ -520,3 +600,103 @@ test('token accounting runs for every ending and never decides one', async () =>
   )
   assert.equal(turns.get(execution.messageId)?.outcome?.status, 'completed')
 })
+
+test('a transient failure before anything is shown is retried, and the answer arrives', async () => {
+  const { store, turns } = fakeStore()
+  const manager = new ChatStreamManager({
+    store,
+    sessionAutoSwitchService: fakeAutoSwitch().service
+  })
+  const browser = collectEvents()
+  const provider = flakyClient(1, '429 Too Many Requests', 'the answer, second try')
+
+  const execution = manager.start({ ...turnRequest(provider.client), emit: browser.emit })
+  await browser.outcome
+
+  assert.equal(execution.status, 'completed', 'the retry did not produce an answer')
+  assert.equal(turns.get(execution.messageId)?.content, 'the answer, second try')
+  assert.equal(provider.calls(), 2, 'the turn was not attempted twice')
+  // Nothing of the first attempt reached the reader.
+  assert.equal(
+    browser.chunkTypes().includes('text-delta'),
+    true,
+    'the second attempt’s answer was never forwarded'
+  )
+})
+
+test('a transient failure after content has been shown is reported, not retried', async () => {
+  const { store, turns } = fakeStore()
+  const manager = new ChatStreamManager({
+    store,
+    sessionAutoSwitchService: fakeAutoSwitch().service
+  })
+  const browser = collectEvents()
+
+  const execution = manager.start({
+    ...turnRequest(erroringClient('half an answer')),
+    emit: browser.emit
+  })
+  await browser.outcome
+
+  // 'socket hang up' is transient, but the reader already has half an answer: a
+  // second attempt would duplicate or silently replace it.
+  assert.equal(turns.get(execution.messageId)?.outcome?.status, 'failed')
+  assert.equal(turns.get(execution.messageId)?.content, 'half an answer')
+})
+
+test('a deterministic failure is not retried', async () => {
+  const { store, turns } = fakeStore()
+  const manager = new ChatStreamManager({
+    store,
+    sessionAutoSwitchService: fakeAutoSwitch().service
+  })
+  const browser = collectEvents()
+  const provider = flakyClient(99, 'invalid api key', 'never')
+
+  const execution = manager.start({ ...turnRequest(provider.client), emit: browser.emit })
+  await browser.outcome
+
+  assert.equal(provider.calls(), 1, 'a deterministic failure was retried')
+  assert.equal(turns.get(execution.messageId)?.outcome?.status, 'failed')
+})
+
+test('retries are bounded, so a provider that is down is not hammered', async () => {
+  const { store, turns } = fakeStore()
+  const manager = new ChatStreamManager({
+    store,
+    sessionAutoSwitchService: fakeAutoSwitch().service
+  })
+  const browser = collectEvents()
+  const provider = flakyClient(99, '503 Service Unavailable', 'never')
+
+  const execution = manager.start({ ...turnRequest(provider.client), emit: browser.emit })
+  await browser.outcome
+
+  assert.equal(provider.calls(), MAX_ATTEMPTS, 'the attempts were not bounded')
+  assert.equal(turns.get(execution.messageId)?.outcome?.status, 'failed')
+})
+
+test('a stream that goes quiet is cancelled and fails with a timeout', async () => {
+  const { store, turns } = fakeStore()
+  const manager = new ChatStreamManager({
+    store,
+    sessionAutoSwitchService: fakeAutoSwitch().service,
+    idleTimeoutMs: 30
+  })
+  const browser = collectEvents()
+  const provider = silentClient('half an answer, then silence')
+
+  const execution = manager.start({ ...turnRequest(provider.client), emit: browser.emit })
+  await browser.outcome
+
+  assert.equal(provider.cancelled(), true, 'the silent request was never cancelled')
+  const record = turns.get(execution.messageId)
+  assert.equal(record?.outcome?.status, 'failed')
+  assert.equal(
+    record?.content,
+    'half an answer, then silence',
+    'the deadline dropped the part that had arrived'
+  )
+  if (record?.outcome?.status !== 'failed') throw new Error('unreachable')
+  assert.equal(record.outcome.reason, 'timeout', 'the failure was not recorded as a timeout')
+})
diff --git a/test/retryPolicy.test.ts b/test/retryPolicy.test.ts
new file mode 100644
index 0000000..2dc41a8
--- /dev/null
+++ b/test/retryPolicy.test.ts
@@ -0,0 +1,99 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  MAX_ATTEMPTS,
+  isRetryableFailure,
+  retryDelayMs,
+  shouldRetry
+} from '../src/main/services/chat/retryPolicy.ts'
+import { failedOutcome } from '../src/shared/utils/chatExecution.ts'
+
+/**
+ * When a failed turn is worth attempting again (#150).
+ *
+ * The direction this is wrong in matters: retrying a deterministic failure costs the
+ * reader a second wait for the same error, so only recognisably transient failures
+ * qualify and everything else is reported as it is.
+ */
+
+test('transient failures are recognised by what the provider said', () => {
+  for (const message of [
+    'Rate limit reached for requests',
+    '429 Too Many Requests',
+    'upstream provider returned 500',
+    'the server is overloaded',
+    'request timed out',
+    'socket hang up',
+    'fetch failed',
+    'read ECONNRESET'
+  ]) {
+    assert.equal(
+      isRetryableFailure(failedOutcome(message, 'error')),
+      true,
+      `not recognised as transient: ${message}`
+    )
+  }
+})
+
+test('a deterministic failure is not retried, and neither is an unknown one', () => {
+  for (const message of [
+    'content policy violation',
+    'invalid api key',
+    'model not found',
+    'the request was malformed',
+    'No valid conversation history',
+    // Unrecognised on purpose: the default is not to retry.
+    'something the provider invented'
+  ]) {
+    assert.equal(
+      isRetryableFailure(failedOutcome(message, 'error')),
+      false,
+      `wrongly treated as transient: ${message}`
+    )
+  }
+})
+
+test('a stream that went quiet or ended without saying anything is the connection’s fault', () => {
+  assert.equal(isRetryableFailure(failedOutcome('The model stopped responding.', 'timeout')), true)
+  assert.equal(
+    isRetryableFailure(failedOutcome('The stream ended without a reason.', 'unexpected_eof')),
+    true
+  )
+})
+
+test('an ending that is not a failure is never retried', () => {
+  for (const outcome of [
+    { status: 'completed' as const },
+    { status: 'truncated' as const },
+    { status: 'blocked' as const },
+    { status: 'aborted' as const, reason: 'user' as const }
+  ]) {
+    assert.equal(isRetryableFailure(outcome), false, outcome.status)
+  }
+})
+
+test('a retry needs a transient failure, room to try, and nothing shown yet', () => {
+  const transient = failedOutcome('429 Too Many Requests', 'error')
+  const deterministic = failedOutcome('invalid api key', 'error')
+
+  assert.equal(shouldRetry({ outcome: transient, attempt: 1, contentSent: false }), true)
+  assert.equal(
+    shouldRetry({ outcome: transient, attempt: MAX_ATTEMPTS, contentSent: false }),
+    false,
+    'the attempts are bounded'
+  )
+  assert.equal(
+    shouldRetry({ outcome: transient, attempt: 1, contentSent: true }),
+    false,
+    'content has reached the reader, so a second attempt cannot replace it cleanly'
+  )
+  assert.equal(shouldRetry({ outcome: deterministic, attempt: 1, contentSent: false }), false)
+})
+
+test('backoff grows with each attempt, starting immediately after the first failure', () => {
+  // The first retry waits a little; later ones wait more, so a provider that is down
+  // is not hammered.
+  assert.equal(retryDelayMs(2), 500)
+  assert.equal(retryDelayMs(3), 1000)
+  assert.ok(retryDelayMs(4) > retryDelayMs(3))
+})
diff --git a/test/streamChat.test.ts b/test/streamChat.test.ts
index b431015..00de06f 100644
--- a/test/streamChat.test.ts
+++ b/test/streamChat.test.ts
@@ -51,6 +51,29 @@ const clientFor = (chunks: LanguageModelV2StreamPart[]): ModelClient => {
   return client
 }
 
+/** Builds a client and hands back the model, so the call args can be inspected. */
+const inspectingClient = (
+  connectionOverride: Partial<ModelConnection>
+): { client: ModelClient; model: MockLanguageModelV2 } => {
+  const model = new MockLanguageModelV2({
+    doStream: async () => ({
+      stream: simulateReadableStream({
+        chunks: [
+          { type: 'stream-start', warnings: [] },
+          {
+            type: 'finish',
+            finishReason: 'stop',
+            usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 }
+          }
+        ] as never[]
+      })
+    })
+  })
+  const client = new ModelClient('chat', { ...connection, ...connectionOverride })
+  client.getAIModel = () => model
+  return { client, model }
+}
+
 test('the stream is the SDK’s own event stream, not a reduced protocol of ours', async () => {
   const client = clientFor([
     { type: 'reasoning-start', id: 'r1' },
@@ -186,3 +209,19 @@ test('the signal the caller passes is the one that cancels the request', async (
   await streaming
   assert.equal(seen.at(-1), 'abort', 'an aborted request did not end as an abort')
 })
+
+test('no ceiling is sent unless the connection asks for one', async () => {
+  // The reasoning-model case: thinking tokens share this budget, so a hard-coded
+  // default was a ceiling reached early (#150).
+  const withoutCeiling = inspectingClient({})
+  await collect(withoutCeiling.client.streamChat([{ role: 'user', content: 'hi' }]).events)
+  assert.equal(
+    withoutCeiling.model.doStreamCalls[0]?.maxOutputTokens,
+    undefined,
+    'a ceiling was sent for a connection that asked for none'
+  )
+
+  const withCeiling = inspectingClient({ maxOutputTokens: 8192 })
+  await collect(withCeiling.client.streamChat([{ role: 'user', content: 'hi' }]).events)
+  assert.equal(withCeiling.model.doStreamCalls[0]?.maxOutputTokens, 8192)
+})