tulingcode 0.1.0

package/test/session/main-lifecycle.test.ts

@@ -0,0 +1,51 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Layer, ManagedRuntime } from "effect"
+import { ActorRegistry } from "../../src/actor/registry"
+import { Session } from "../../src/session"
+import { Instance } from "../../src/project/instance"
+import { Log } from "../../src/util"
+import { tmpdir } from "../fixture/fixture"
+
+void Log.init({ print: false })
+
+const testLayer = Layer.mergeAll(Session.defaultLayer, ActorRegistry.defaultLayer)
+
+afterEach(async () => {
+  await Instance.disposeAll()
+})
+
+async function withServices(
+  directory: string,
+  fn: (rt: ManagedRuntime.ManagedRuntime<Session.Service | ActorRegistry.Service, never>) => Promise<void>,
+) {
+  return Instance.provide({
+    directory,
+    fn: async () => {
+      const rt = ManagedRuntime.make(testLayer)
+      try {
+        await fn(rt)
+      } finally {
+        await rt.dispose()
+      }
+    },
+  })
+}
+
+describe("Session.create main lifecycle (Plan 1 / Task 6)", () => {
+  test("main actor lifecycle = persistent on session create", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await withServices(tmp.path, async (rt) => {
+      const session = await rt.runPromise(Session.Service.use((svc) => svc.create()))
+
+      const entry = await rt.runPromise(
+        ActorRegistry.Service.use((reg) => reg.get(session.id, "main")),
+      )
+
+      expect(entry).toBeDefined()
+      expect(entry!.lifecycle).toBe("persistent")
+      expect(entry!.mode).toBe("main")
+      expect(entry!.status).toBe("pending")
+      expect(entry!.lastOutcome).toBeUndefined()
+    })
+  })
+})

package/test/session/main-runloop-history-invariant.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Integration test: main runLoop history monotonic-growth invariant.
+ *
+ * Drives a real Session.prompt(...) call through main runLoop's multi-step
+ * iteration against a scripted HTTP LLM stub. Asserts that each successive
+ * /chat/completions request contains strictly more messages than the previous
+ * one — i.e. history is monotonically growing across steps.
+ *
+ * This catches a different failure mode than the unit test in
+ * test/session/llm-request-prefix.test.ts: this fires if main runLoop is
+ * wired to a non-monotonic prefix builder, or if some history-stripping logic
+ * creeps in elsewhere on the stream path (e.g. a future PR replaces
+ * buildLLMRequestPrefix with a different builder).
+ *
+ * Design notes:
+ * - LLM.defaultLayer is baked into AppRuntime's ManagedRuntime at construction
+ *   time, so Effect.provideService(LLM.Service, fake) cannot override it. The
+ *   established pattern in this codebase is to spin up a Bun.serve HTTP mock
+ *   that speaks OpenAI-compatible SSE, then point the project config's
+ *   provider.baseURL at that mock. See prompt.test.ts, llm-system-prompt.test.ts.
+ * - Step 0: mock returns a tool-call (read on the tmp README). runLoop executes
+ *   the tool and makes a second LLM call.
+ * - Step 1: mock returns text + stop. runLoop terminates.
+ * - We assert captures[1].messages.length > captures[0].messages.length and
+ *   that captures[1].messages[0..n-1] === captures[0].messages[0..n-1].
+ */
+
+import path from "path"
+import { afterEach, describe, expect, test } from "bun:test"
+import { Effect, Layer } from "effect"
+import { Instance } from "../../src/project/instance"
+import { Session } from "../../src/session"
+import { SessionPrompt } from "../../src/session/prompt"
+import { Log } from "../../src/util"
+import { tmpdir } from "../fixture/fixture"
+import { startScriptedLLMServer, toolCallResponse, textStopResponse, textLengthResponse } from "../lib/scripted-llm-server"
+
+void Log.init({ print: false })
+
+afterEach(async () => {
+  await Instance.disposeAll()
+})
+
+function run<A, E>(fx: Effect.Effect<A, E, SessionPrompt.Service | Session.Service>) {
+  return Effect.runPromise(
+    fx.pipe(Effect.scoped, Effect.provide(Layer.mergeAll(SessionPrompt.defaultLayer, Session.defaultLayer))),
+  )
+}
+
+describe("main runLoop history monotonic-growth invariant", () => {
+  test("each step's /chat/completions request strictly contains previous step's messages", async () => {
+    // Create the tmp dir first (without init) so we know the real path before
+    // constructing responses — this avoids any post-start mutation of the
+    // responses array.
+    await using tmp = await tmpdir({ git: true })
+
+    const readmePath = path.join(tmp.path, "README.md")
+
+    // Step 0: LLM replies with a read tool-call on the tmp README.
+    // Step 1: LLM replies with plain text + stop.
+    // Both constructed with the real path already baked in.
+    const responses = [
+      { lines: toolCallResponse({ id: "call_0", name: "read", args: JSON.stringify({ filePath: readmePath }) }) },
+      { lines: textStopResponse("done.") },
+    ]
+
+    const stub = startScriptedLLMServer(responses)
+
+    try {
+      // Populate the tmp dir now that we have stub.origin.
+      await Bun.write(readmePath, "# Hello\n")
+      await Bun.write(
+        path.join(tmp.path, "tulingcode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          enabled_providers: ["alibaba"],
+          provider: {
+            alibaba: {
+              options: {
+                apiKey: "test-key",
+                baseURL: `${stub.origin}/v1`,
+              },
+            },
+          },
+          agent: {
+            build: { model: "alibaba/qwen-plus" },
+          },
+        }),
+      )
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: () =>
+          run(
+            Effect.gen(function* () {
+              const sessions = yield* Session.Service
+              const prompt = yield* SessionPrompt.Service
+              const session = yield* sessions.create({ title: "history-invariant" })
+
+              yield* prompt.prompt({
+                sessionID: session.id,
+                agent: "build",
+                parts: [{ type: "text", text: "Please read the README." }],
+              })
+
+              // Verify the invariant: at least 2 LLM calls were made.
+              expect(stub.captures.length).toBeGreaterThanOrEqual(2)
+
+              const cap0 = stub.captures[0].messages
+              const cap1 = stub.captures[1].messages
+
+              // Step 1's message list must be strictly longer (tool result was appended).
+              expect(cap1.length).toBeGreaterThan(cap0.length)
+
+              // Every message from step 0 must appear at the same index in step 1
+              // (prefix is preserved, not rebuilt from scratch).
+              for (let i = 0; i < cap0.length; i++) {
+                expect(cap1[i]).toEqual(cap0[i])
+              }
+            }),
+          ),
+      })
+    } finally {
+      await stub.stop()
+    }
+  })
+
+  test("auto-continues when a step finishes because of output length", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const responses = [
+      { lines: textLengthResponse("partial answer") },
+      { lines: textStopResponse("done.") },
+    ]
+    const stub = startScriptedLLMServer(responses)
+
+    try {
+      await Bun.write(
+        path.join(tmp.path, "tulingcode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          enabled_providers: ["alibaba"],
+          provider: {
+            alibaba: {
+              options: {
+                apiKey: "test-key",
+                baseURL: `${stub.origin}/v1`,
+              },
+            },
+          },
+          agent: {
+            build: { model: "alibaba/qwen-plus" },
+          },
+        }),
+      )
+
+      await Instance.provide({
+        directory: tmp.path,
+        fn: () =>
+          run(
+            Effect.gen(function* () {
+              const sessions = yield* Session.Service
+              const prompt = yield* SessionPrompt.Service
+              const session = yield* sessions.create({ title: "length-continuation" })
+
+              const final = yield* prompt.prompt({
+                sessionID: session.id,
+                agent: "build",
+                parts: [{ type: "text", text: "Produce an answer that may need continuation." }],
+              })
+
+              expect(stub.captures.length).toBe(2)
+              expect(JSON.stringify(stub.captures[1].messages)).toContain("output token limit")
+              expect(final.parts.some((part) => part.type === "text" && part.text === "done.")).toBe(true)
+            }),
+          ),
+      })
+    } finally {
+      await stub.stop()
+    }
+  })
+})

package/test/session/max-mode-econnreset.test.ts

@@ -0,0 +1,229 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import * as Stream from "effect/Stream"
+import { runCandidate, judge, type MaxStepInput } from "../../src/session/max-mode"
+import type { LLM } from "../../src/session/llm"
+
+/**
+ * Integration tests for the ECONNRESET fix: drive the REAL runCandidate / judge
+ * with a mock llm.stream that emits an AI-SDK-style `error` stream PART (the SDK
+ * does not throw on transient failures — it yields {type:"error"} then ends the
+ * stream normally). These assert that:
+ *   1. a transient error part is retried (not silently swallowed),
+ *   2. retry uses a fresh accumulator (no duplicated text),
+ *   3. a non-transient error part falls through to the catch fallback.
+ *
+ * The mock stream yields synchronously-constructed events, so the only real
+ * wall-clock cost is persistentRetrySchedule's first backoff (~500ms/attempt).
+ */
+
+const econnreset = () => Object.assign(new Error("socket connection closed unexpectedly"), { code: "ECONNRESET" })
+const httpBadRequest = () => Object.assign(new Error("Bad Request"), { status: 400 })
+
+/** Build a mock LLM whose stream fails `failTimes` times (error part) then succeeds. */
+function mockLLM(opts: {
+  failTimes: number
+  makeError: () => Error
+  goodEvents: LLM.Event[]
+  errorEvents?: LLM.Event[]
+}): { llm: LLM.Interface; attempts: () => number } {
+  let attempt = 0
+  const llm = {
+    buildSystemArray: () => Effect.succeed([]),
+    stream: (_input: any): Stream.Stream<LLM.Event, unknown> => {
+      const thisAttempt = attempt++
+      const events: LLM.Event[] =
+        thisAttempt < opts.failTimes
+          ? [...(opts.errorEvents ?? []), { type: "error", error: opts.makeError() } as LLM.Event]
+          : opts.goodEvents
+      return Stream.fromIterable(events)
+    },
+  } as unknown as LLM.Interface
+  return { llm, attempts: () => attempt }
+}
+
+function baseInput(llm: LLM.Interface): MaxStepInput {
+  return {
+    handle: {} as any,
+    llm,
+    user: {} as any,
+    agent: {} as any,
+    model: {} as any,
+    sessionID: "ses_test",
+    system: [],
+    messages: [],
+    tools: {},
+  }
+}
+
+describe("max-mode ECONNRESET handling (integration)", () => {
+  test("candidate retries a transient error part and recovers with a fresh accumulator", async () => {
+    // Each attempt's "good" path emits text then finishes. On failing attempts
+    // we ALSO emit a text-delta before the error part, to prove the retry does
+    // not concatenate partial text from the failed attempt.
+    const { llm, attempts } = mockLLM({
+      failTimes: 2,
+      makeError: econnreset,
+      errorEvents: [{ type: "text-delta", text: "PARTIAL " } as LLM.Event],
+      goodEvents: [
+        { type: "reasoning-delta", text: "think" } as LLM.Event,
+        { type: "text-delta", text: "final answer" } as LLM.Event,
+        { type: "tool-call", toolCallId: "c1", toolName: "read", input: { filePath: "/x" } } as LLM.Event,
+        { type: "finish-step", finishReason: "tool-calls", usage: { inputTokens: 1, outputTokens: 2 } } as LLM.Event,
+      ],
+    })
+
+    const candidate = await Effect.runPromise(runCandidate(baseInput(llm), 0))
+
+    expect(candidate).not.toBeNull()
+    expect(attempts()).toBe(3) // 2 failed + 1 success
+    // fresh accumulator: NO "PARTIAL " leaked from the failed attempts
+    expect(candidate!.text).toBe("final answer")
+    expect(candidate!.reasoning).toBe("think")
+    expect(candidate!.toolCalls).toHaveLength(1)
+    expect(candidate!.toolCalls[0].toolName).toBe("read")
+    expect(candidate!.finishReason).toBe("tool-calls")
+  })
+
+  test("candidate gives up (returns null) on a non-transient error part", async () => {
+    const { llm, attempts } = mockLLM({
+      failTimes: 99, // always fail
+      makeError: httpBadRequest, // 400 → not transient → must NOT retry
+      goodEvents: [],
+    })
+
+    const candidate = await Effect.runPromise(runCandidate(baseInput(llm), 0))
+
+    expect(candidate).toBeNull()
+    expect(attempts()).toBe(1) // no retry for a 400
+  })
+
+  test("judge retries a transient error part instead of collapsing to pick 0", async () => {
+    // Two candidates; the judge should pick index 1. It fails once (transient)
+    // then succeeds — a non-retrying judge would have returned pick 0.
+    const { llm, attempts } = mockLLM({
+      failTimes: 1,
+      makeError: econnreset,
+      goodEvents: [
+        { type: "text-delta", text: "1" } as LLM.Event,
+        { type: "finish-step", finishReason: "stop", usage: { inputTokens: 1, outputTokens: 1 } } as LLM.Event,
+      ],
+    })
+
+    const candidates = [
+      { index: 0, reasoning: "", text: "a", toolCalls: [], finishReason: "stop" },
+      { index: 1, reasoning: "", text: "b", toolCalls: [], finishReason: "stop" },
+    ]
+
+    const result = await Effect.runPromise(judge(baseInput(llm), candidates as any))
+
+    expect(attempts()).toBe(2) // 1 failed + 1 success
+    expect(result.pick).toBe(1) // recovered the real pick, not the pick-0 fallback
+  })
+
+  test("judge falls back to pick 0 on a non-transient error part", async () => {
+    const { llm, attempts } = mockLLM({
+      failTimes: 99,
+      makeError: httpBadRequest,
+      goodEvents: [],
+    })
+
+    const candidates = [
+      { index: 0, reasoning: "", text: "a", toolCalls: [], finishReason: "stop" },
+      { index: 1, reasoning: "", text: "b", toolCalls: [], finishReason: "stop" },
+    ]
+
+    const result = await Effect.runPromise(judge(baseInput(llm), candidates as any))
+
+    expect(attempts()).toBe(1) // no retry for a 400
+    expect(result.pick).toBe(0) // graceful fallback
+  })
+})
+
+describe("max-mode defect handling (SSE timeout surfaces as Cause.die)", () => {
+  // Unlike an `error` stream PART, the real SSE-timeout / aborted-fetch error is
+  // raised deep in the provider stream as a DEFECT (Cause.die). The old code
+  // (retry + Effect.catch, no catchCause) let it escape the fiber as an
+  // unhandled rejection that killed the whole session — exactly what the
+  // eval logs showed (bare `error: SSE read timed out`, no candidate-failed
+  // log, no retry). These tests drive the REAL runCandidate / judge with a
+  // stream that dies mid-consumption and assert the defect is now contained.
+
+  /** A mock LLM whose stream DIES (defect) `dieTimes` times, then succeeds. */
+  function dyingLLM(opts: { dieTimes: number; makeError: () => Error; goodEvents: LLM.Event[] }) {
+    let attempt = 0
+    const llm = {
+      buildSystemArray: () => Effect.succeed([]),
+      stream: (_input: any): Stream.Stream<LLM.Event, unknown> => {
+        const thisAttempt = attempt++
+        if (thisAttempt < opts.dieTimes) {
+          // throw inside Stream.tap's Effect.sync => surfaces as a DEFECT,
+          // matching how the provider raises SSE timeout mid-stream.
+          return Stream.fromIterable([{ type: "text-delta", text: "partial" } as LLM.Event]).pipe(
+            Stream.tap(() =>
+              Effect.sync(() => {
+                throw opts.makeError()
+              }),
+            ),
+          )
+        }
+        return Stream.fromIterable(opts.goodEvents)
+      },
+    } as unknown as LLM.Interface
+    return { llm, attempts: () => attempt }
+  }
+
+  const sseTimeout = () => new Error("SSE read timed out")
+  // A non-transient defect: not retried, so containment is proven in 1 attempt
+  // without waiting out persistentRetrySchedule's ~8min backoff exhaustion.
+  const fatalDefect = () => new Error("unexpected internal stream failure")
+
+  test("candidate contains a transient defect and retries to recovery (no fiber crash)", async () => {
+    const { llm, attempts } = dyingLLM({
+      dieTimes: 2,
+      makeError: sseTimeout, // "SSE read timed out" is transient -> retried
+      goodEvents: [
+        { type: "text-delta", text: "recovered" } as LLM.Event,
+        { type: "finish-step", finishReason: "stop", usage: { inputTokens: 1, outputTokens: 1 } } as LLM.Event,
+      ],
+    })
+
+    // runPromiseExit, not runPromise: if the defect escaped (old behaviour) this
+    // would be a Failure/Die, not a Success.
+    const exit = await Effect.runPromiseExit(runCandidate(baseInput(llm), 0))
+
+    expect(exit._tag).toBe("Success")
+    if (exit._tag === "Success") {
+      expect(exit.value).not.toBeNull()
+      expect(exit.value!.text).toBe("recovered")
+    }
+    expect(attempts()).toBe(3) // 2 defect attempts + 1 success
+  })
+
+  test("candidate degrades a defect to null instead of crashing the fiber", async () => {
+    // Non-transient defect: catchCause contains it and catch degrades to null in
+    // ONE attempt (no retry), which is the decisive containment property.
+    const { llm, attempts } = dyingLLM({ dieTimes: 99, makeError: fatalDefect, goodEvents: [] })
+
+    const exit = await Effect.runPromiseExit(runCandidate(baseInput(llm), 0))
+
+    // The decisive assertion: the defect is CONTAINED (Success with null),
+    // never escaping as a Die that would bubble to the session and kill it.
+    expect(exit._tag).toBe("Success")
+    if (exit._tag === "Success") expect(exit.value).toBeNull()
+    expect(attempts()).toBe(1) // non-transient -> not retried
+  })
+
+  test("judge contains a defect and falls back to pick 0", async () => {
+    const { llm } = dyingLLM({ dieTimes: 99, makeError: fatalDefect, goodEvents: [] })
+    const candidates = [
+      { index: 0, reasoning: "", text: "a", toolCalls: [], finishReason: "stop" },
+      { index: 1, reasoning: "", text: "b", toolCalls: [], finishReason: "stop" },
+    ]
+
+    const exit = await Effect.runPromiseExit(judge(baseInput(llm), candidates as any))
+
+    expect(exit._tag).toBe("Success")
+    if (exit._tag === "Success") expect(exit.value.pick).toBe(0)
+  })
+})

package/test/session/max-mode.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test"
+import { toSchemaOnlyTools, parseJudgeIndex } from "../../src/session/max-mode"
+
+describe("max-mode toSchemaOnlyTools", () => {
+  test("strips execute closures but keeps schema fields", () => {
+    const tools = {
+      read: { description: "Read a file", inputSchema: { type: "object" }, execute: async () => ({}) },
+      bash: { description: "Run a command", inputSchema: { type: "object" }, execute: async () => ({}) },
+    } as any
+
+    const out = toSchemaOnlyTools(tools)
+
+    expect(Object.keys(out).sort()).toEqual(["bash", "read"])
+    for (const key of Object.keys(out)) {
+      expect((out[key] as any).execute).toBeUndefined()
+      expect((out[key] as any).description).toBe((tools[key] as any).description)
+      expect((out[key] as any).inputSchema).toBe((tools[key] as any).inputSchema)
+    }
+  })
+
+  test("does not mutate the input tools", () => {
+    const tools = {
+      read: { description: "Read", inputSchema: {}, execute: async () => ({}) },
+    } as any
+    toSchemaOnlyTools(tools)
+    expect(typeof (tools.read as any).execute).toBe("function")
+  })
+})
+
+describe("max-mode parseJudgeIndex", () => {
+  test("parses a bare integer", () => {
+    expect(parseJudgeIndex("2", 5)).toBe(2)
+  })
+
+  test("extracts the first integer from prose", () => {
+    expect(parseJudgeIndex("I pick candidate 3 because it is best.", 5)).toBe(3)
+  })
+
+  test("defaults to 0 when no integer present", () => {
+    expect(parseJudgeIndex("none of them", 5)).toBe(0)
+  })
+
+  test("defaults to 0 when index out of range", () => {
+    expect(parseJudgeIndex("9", 5)).toBe(0)
+  })
+
+  test("accepts boundary index 0", () => {
+    expect(parseJudgeIndex("0", 5)).toBe(0)
+  })
+
+  test("accepts last valid index", () => {
+    expect(parseJudgeIndex("4", 5)).toBe(4)
+  })
+})