refactor(opencode): simplify output cap

Author: MagMueller

packages/opencode/src/session/processor.ts

@@ -734,6 +734,8 @@ const layer = Layer.effect(
               SessionRetry.policy({
                 provider: input.model.providerID,
                 parse,
+                // Only replace attempts that will be retried. Cloud intentionally
+                // returns the terminal partial next to the truncation error.
                 onRetry: (error) =>
                   SessionV1.OutputLengthError.isInstance(error) ? resetOutputLimit() : Effect.void,
                 set: (info) => {

packages/opencode/src/session/retry.ts

@@ -23,6 +23,7 @@ export type RetryReason = "free_tier_limit" | "account_rate_limit" | (string & {
 
 export type Retryable = {
   message: string
+  maxAttempts?: number
   action?: {
     reason: RetryReason
     provider: string
@@ -37,7 +38,6 @@ export const RETRY_INITIAL_DELAY = 2000
 export const RETRY_BACKOFF_FACTOR = 2
 export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
 export const RETRY_MAX_DELAY = 2_147_483_647 // max 32-bit signed integer for setTimeout
-export const OUTPUT_LENGTH_MAX_RETRIES = 2
 
 function cap(ms: number) {
   return Math.min(ms, RETRY_MAX_DELAY)
@@ -77,7 +77,9 @@ export function delay(attempt: number, error?: SessionV1.APIError) {
 }
 
 export function retryable(error: Err, provider: string) {
-  if (SessionV1.OutputLengthError.isInstance(error)) return { message: "Model hit its output limit" }
+  if (SessionV1.OutputLengthError.isInstance(error)) {
+    return { message: "Model hit its output limit", maxAttempts: 3 }
+  }
   // context overflow errors should not be retried
   if (SessionV1.ContextOverflowError.isInstance(error)) return undefined
   if (SessionV1.APIError.isInstance(error)) {
@@ -191,15 +193,12 @@ export function policy(opts: {
   onRetry?: (error: Err) => Effect.Effect<void>
   set: (input: { attempt: number; message: string; action?: Retryable["action"]; next: number }) => Effect.Effect<void>
 }) {
-  let outputLengthRetries = 0
   return Schedule.fromStepWithMetadata(
     Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
       const error = opts.parse(meta.input)
       const retry = retryable(error, opts.provider)
       if (!retry) return Cause.done(meta.attempt)
-      if (SessionV1.OutputLengthError.isInstance(error) && ++outputLengthRetries > OUTPUT_LENGTH_MAX_RETRIES) {
-        return Cause.done(meta.attempt)
-      }
+      if (retry.maxAttempts !== undefined && meta.attempt >= retry.maxAttempts) return Cause.done(meta.attempt)
       return Effect.gen(function* () {
         if (opts.onRetry) yield* opts.onRetry(error)
         const wait = delay(meta.attempt, SessionV1.APIError.isInstance(error) ? error : undefined)

packages/opencode/test/session/processor-effect.test.ts

@@ -249,6 +249,10 @@ const fragmentFailureEnv = LayerNode.compile(root, [...replacements, [LLM.node,
 const itFragmentFailure = testEffect(fragmentFailureEnv)
 
 const outputRetryInputs: LLM.StreamInput[] = []
+const outputRetryUsage = {
+  truncated: { input: 3, output: 5 },
+  complete: { input: 7, output: 11 },
+} as const
 const outputRetryLLM = Layer.succeed(
   LLM.Service,
   LLM.Service.of({
@@ -263,7 +267,10 @@ const outputRetryLLM = Layer.succeed(
         LLMEvent.stepFinish({
           index: 0,
           reason: first ? "length" : "stop",
-          usage: first ? { inputTokens: 3, outputTokens: 5 } : { inputTokens: 7, outputTokens: 11 },
+          usage: {
+            inputTokens: first ? outputRetryUsage.truncated.input : outputRetryUsage.complete.input,
+            outputTokens: first ? outputRetryUsage.truncated.output : outputRetryUsage.complete.output,
+          },
         }),
         LLMEvent.finish({ reason: first ? "length" : "stop" }),
       )
@@ -600,12 +607,14 @@ itOutputRetry.live("session.processor effect tests resample the exact request af
       expect(outputRetryInputs[1]).toBe(outputRetryInputs[0])
       expect(parts.filter((part) => part.type === "text").map((part) => part.text)).toStrictEqual(["complete"])
       const finishes = parts.filter((part) => part.type === "step-finish")
+      const input = outputRetryUsage.truncated.input + outputRetryUsage.complete.input
+      const output = outputRetryUsage.truncated.output + outputRetryUsage.complete.output
       expect(finishes).toHaveLength(1)
       expect(finishes[0]).toMatchObject({
         reason: "stop",
-        tokens: { input: 10, output: 16 },
+        tokens: { input, output },
       })
-      expect(finishes[0]?.cost).toBeCloseTo(0.000026)
+      expect(finishes[0]?.cost).toBeCloseTo((input + output) / 1_000_000)
       expect(handle.message.finish).toBe("stop")
     }),
   ),

packages/opencode/test/session/retry.test.ts

@@ -116,7 +116,7 @@ describe("session.retry.delay", () => {
     }),
   )
 
-  it.effect("policy caps output-length errors at two retries", () =>
+  it.effect("policy caps output-length errors at three total calls", () =>
     Effect.gen(function* () {
       const error = new SessionV1.OutputLengthError({}).toObject()
       const attempts: number[] = []