@miaws/miaw 1.18.5 → 1.18.7

package/test/session/instruction.test.ts

@@ -1,256 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { SessionV1 } from "@miaw/core/v1/session"
-import path from "path"
-import { Effect, FileSystem, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { NodeFileSystem } from "@effect/platform-node"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { FSUtil } from "@miaw/core/fs-util"
-
-import { Instruction } from "../../src/session/instruction"
-import type { MessageV2 } from "../../src/session/message-v2"
-import { MessageID, PartID, SessionID } from "../../src/session/schema"
-import { Global } from "@miaw/core/global"
-import { RuntimeFlags } from "../../src/effect/runtime-flags"
-import { provideInstance, provideTmpdirInstance, testInstanceStoreLayer, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { TestConfig } from "../fixture/config"
-import { ProviderV2 } from "@miaw/core/provider"
-import { ModelV2 } from "@miaw/core/model"
-
-const it = testEffect(Layer.mergeAll(CrossSpawnSpawner.defaultLayer, NodeFileSystem.layer, testInstanceStoreLayer))
-
-const configLayer = TestConfig.layer()
-
-const instructionLayer = (global: Partial<Global.Interface>, flags: Partial<RuntimeFlags.Info> = {}) =>
-  Instruction.layer.pipe(
-    Layer.provide(configLayer),
-    Layer.provide(FSUtil.defaultLayer),
-    Layer.provide(FetchHttpClient.layer),
-    Layer.provide(Global.layerWith(global)),
-    Layer.provide(RuntimeFlags.layer(flags)),
-  )
-
-const provideInstruction =
-  (global: Partial<Global.Interface>, flags?: Partial<RuntimeFlags.Info>) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    self.pipe(Effect.provide(instructionLayer(global, flags)))
-
-const write = (filepath: string, content: string) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    yield* fs.makeDirectory(path.dirname(filepath), { recursive: true })
-    yield* fs.writeFileString(filepath, content)
-  })
-
-const writeFiles = (dir: string, files: Record<string, string>) =>
-  Effect.all(
-    Object.entries(files).map(([file, content]) => write(path.join(dir, file), content)),
-    { discard: true },
-  )
-
-const withFiles = <A, E, R>(files: Record<string, string>, self: (dir: string) => Effect.Effect<A, E, R>) =>
-  provideTmpdirInstance((dir) =>
-    Effect.gen(function* () {
-      yield* writeFiles(dir, files)
-      return yield* self(dir).pipe(provideInstruction({ home: dir, config: dir }))
-    }),
-  )
-
-const tmpWithFiles = (files: Record<string, string>) =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped()
-    yield* writeFiles(dir, files)
-    return dir
-  })
-
-function loaded(filepath: string): SessionV1.WithParts[] {
-  const sessionID = SessionID.make("session-loaded-1")
-  const messageID = MessageID.make("msg_message-loaded-1")
-
-  return [
-    {
-      info: {
-        id: messageID,
-        sessionID,
-        role: "user",
-        time: { created: 0 },
-        agent: "build",
-        model: {
-          providerID: ProviderV2.ID.make("anthropic"),
-          modelID: ModelV2.ID.make("claude-sonnet-4-20250514"),
-        },
-      },
-      parts: [
-        {
-          id: PartID.make("prt_part-loaded-1"),
-          messageID,
-          sessionID,
-          type: "tool",
-          callID: "call-loaded-1",
-          tool: "read",
-          state: {
-            status: "completed",
-            input: {},
-            output: "done",
-            title: "Read",
-            metadata: { loaded: [filepath] },
-            time: { start: 0, end: 1 },
-          },
-        },
-      ],
-    },
-  ]
-}
-
-describe("Instruction.resolve", () => {
-  it.live("returns empty when AGENTS.md is at project root (already in systemPaths)", () =>
-    withFiles({ "AGENTS.md": "# Root Instructions", "src/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const system = yield* svc.systemPaths()
-        expect(system.has(path.join(dir, "AGENTS.md"))).toBe(true)
-
-        const results = yield* svc.resolve([], path.join(dir, "src", "file.ts"), MessageID.make("msg_message-test-1"))
-        expect(results).toEqual([])
-      }),
-    ),
-  )
-
-  it.live("returns AGENTS.md from subdirectory (not in systemPaths)", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const system = yield* svc.systemPaths()
-        expect(system.has(path.join(dir, "subdir", "AGENTS.md"))).toBe(false)
-
-        const results = yield* svc.resolve(
-          [],
-          path.join(dir, "subdir", "nested", "file.ts"),
-          MessageID.make("msg_message-test-2"),
-        )
-        expect(results.length).toBe(1)
-        expect(results[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
-      }),
-    ),
-  )
-
-  it.live("doesn't reload AGENTS.md when reading it directly", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const filepath = path.join(dir, "subdir", "AGENTS.md")
-        const system = yield* svc.systemPaths()
-        expect(system.has(filepath)).toBe(false)
-
-        const results = yield* svc.resolve([], filepath, MessageID.make("msg_message-test-3"))
-        expect(results).toEqual([])
-      }),
-    ),
-  )
-
-  it.live("does not reattach the same nearby instructions twice for one message", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const filepath = path.join(dir, "subdir", "nested", "file.ts")
-        const id = MessageID.make("msg_message-claim-1")
-
-        const first = yield* svc.resolve([], filepath, id)
-        const second = yield* svc.resolve([], filepath, id)
-
-        expect(first).toHaveLength(1)
-        expect(first[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
-        expect(second).toEqual([])
-      }),
-    ),
-  )
-
-  it.live("clear allows nearby instructions to be attached again for the same message", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const filepath = path.join(dir, "subdir", "nested", "file.ts")
-        const id = MessageID.make("msg_message-claim-2")
-
-        const first = yield* svc.resolve([], filepath, id)
-        yield* svc.clear(id)
-        const second = yield* svc.resolve([], filepath, id)
-
-        expect(first).toHaveLength(1)
-        expect(second).toHaveLength(1)
-        expect(second[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
-      }),
-    ),
-  )
-
-  it.live("skips instructions already reported by prior read metadata", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const agents = path.join(dir, "subdir", "AGENTS.md")
-        const filepath = path.join(dir, "subdir", "nested", "file.ts")
-        const id = MessageID.make("msg_message-claim-3")
-
-        const results = yield* svc.resolve(loaded(agents), filepath, id)
-        expect(results).toEqual([])
-      }),
-    ),
-  )
-
-  test.todo("fetches remote instructions from config URLs via HttpClient", () => {})
-})
-
-describe("Instruction.system", () => {
-  it.live("loads both project and global AGENTS.md when both exist", () =>
-    Effect.gen(function* () {
-      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
-      const projectTmp = yield* tmpWithFiles({ "AGENTS.md": "# Project Instructions" })
-
-      yield* Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const paths = yield* svc.systemPaths()
-        expect(paths.has(path.join(projectTmp, "AGENTS.md"))).toBe(true)
-        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(true)
-
-        const rules = yield* svc.system()
-        expect(rules).toHaveLength(2)
-        expect(rules[0]).toBe(`Instructions from: ${path.join(globalTmp, "AGENTS.md")}\n# Global Instructions`)
-        expect(rules[1]).toBe(`Instructions from: ${path.join(projectTmp, "AGENTS.md")}\n# Project Instructions`)
-      }).pipe(provideInstance(projectTmp), provideInstruction({ home: globalTmp, config: globalTmp }))
-    }),
-  )
-
-  it.live("skips project and global CLAUDE.md when Claude Code prompt is disabled", () =>
-    Effect.gen(function* () {
-      const globalTmp = yield* tmpWithFiles({ ".claude/CLAUDE.md": "# Global Claude" })
-      const projectTmp = yield* tmpWithFiles({ "CLAUDE.md": "# Project Claude" })
-
-      yield* Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const paths = yield* svc.systemPaths()
-        expect(paths.has(path.join(globalTmp, ".claude", "CLAUDE.md"))).toBe(false)
-        expect(paths.has(path.join(projectTmp, "CLAUDE.md"))).toBe(false)
-        expect(yield* svc.system()).toEqual([])
-      }).pipe(
-        provideInstance(projectTmp),
-        provideInstruction({ home: globalTmp, config: globalTmp }, { disableClaudeCodePrompt: true }),
-      )
-    }),
-  )
-})
-
-describe("Instruction.systemPaths global config", () => {
-  it.live("uses Global.Service config AGENTS.md", () =>
-    Effect.gen(function* () {
-      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
-      const projectTmp = yield* tmpdirScoped()
-
-      yield* Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const paths = yield* svc.systemPaths()
-        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(true)
-      }).pipe(provideInstance(projectTmp), provideInstruction({ home: globalTmp, config: globalTmp }))
-    }),
-  )
-})

package/test/session/llm-native-recorded.test.ts

@@ -1,433 +0,0 @@
-import { ConfigV1 } from "@miaw/core/v1/config/config"
-import { SessionV1 } from "@miaw/core/v1/session"
-import { FSUtil } from "@miaw/core/fs-util"
-import { ModelsDev } from "@miaw/core/models-dev"
-import { HttpRecorder } from "@miaw/http-recorder"
-import { HttpRecorderInternal } from "@miaw/http-recorder/internal"
-import { describe, expect, test } from "bun:test"
-import { tool, type ModelMessage, type JSONValue } from "ai"
-import { Effect, Layer, Option, Schema, Stream } from "effect"
-import path from "node:path"
-import z from "zod"
-import { Auth } from "@/auth"
-import { Config } from "@/config/config"
-import { Plugin } from "@/plugin"
-import { Provider } from "@/provider/provider"
-
-import { Filesystem } from "@/util/filesystem"
-import { LLMEvent, LLMResponse } from "@miaw/llm"
-import { LLMClient, RequestExecutor, WebSocketExecutor } from "@miaw/llm/route"
-import { Env } from "@/env"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import type { Agent } from "../../src/agent/agent"
-import { LLM } from "../../src/session/llm"
-import { MessageID, SessionID } from "../../src/session/schema"
-import { TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { ProviderV2 } from "@miaw/core/provider"
-import { ModelV2 } from "@miaw/core/model"
-
-const FIXTURES_DIR = path.join(import.meta.dir, "../fixtures/recordings")
-
-const zenURL = (connection: string) => `https://console.miaw/proxy/connections/${connection}/v1`
-
-const replayOpenAIOAuth = {
-  type: "oauth",
-  refresh: "fixture-refresh-token",
-  access: "fixture-access-token",
-  expires: Date.now() + 60 * 60 * 1000,
-  accountId: "fixture-account",
-} satisfies Auth.Info
-
-type RecordedScenario = {
-  readonly id: string
-  readonly name: string
-  readonly providerID: ProviderV2.ID
-  readonly modelID: string
-  readonly cassette: string
-  readonly protocol: string
-  readonly tags: ReadonlyArray<string>
-  readonly canRecord: () => boolean
-  readonly recordAuth?: () => Auth.Info | undefined
-  readonly replayAuth?: Auth.Info
-  readonly stableID?: string
-  readonly config: (model: ModelsDev.Provider["models"][string]) => Partial<ConfigV1.Info>
-}
-
-const cloneModel = (model: ModelsDev.Provider["models"][string]) => {
-  const cloned = structuredClone(model)
-  const { experimental, ...rest } = cloned
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- The config schema accepts the same model shape except object-valued experimental metadata.
-  if (typeof experimental === "boolean") {
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- The fixture model already matches config input when experimental is boolean.
-    return cloned as NonNullable<NonNullable<ConfigV1.Info["provider"]>[string]["models"]>[string]
-  }
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Dropping non-boolean experimental metadata makes the fixture model match config input.
-  return rest as NonNullable<NonNullable<ConfigV1.Info["provider"]>[string]["models"]>[string]
-}
-
-const envValue = (...names: string[]) => names.map((name) => process.env[name]).find(Boolean)
-const decodeAuth = Schema.decodeUnknownOption(Auth.Info)
-const recordOpenAIOAuth = (() => {
-  let loaded = false
-  let auth: Auth.Info | undefined
-  return () => {
-    if (loaded) return auth
-    loaded = true
-    auth = decodeRecordOpenAIOAuth()
-    return auth
-  }
-})()
-
-function decodeRecordOpenAIOAuth() {
-  const value = process.env.MIAW_RECORD_OPENAI_AUTH
-  if (!value) return undefined
-  try {
-    const auth = Option.getOrUndefined(decodeAuth(JSON.parse(value)))
-    return auth?.type === "oauth" ? auth : undefined
-  } catch {
-    return undefined
-  }
-}
-
-const providerConfig = (input: {
-  readonly providerID: ProviderV2.ID
-  readonly name: string
-  readonly env: string[]
-  readonly npm: string
-  readonly api: string
-  readonly model: ModelsDev.Provider["models"][string]
-  readonly options: Record<string, unknown>
-}): Partial<ConfigV1.Info> => ({
-  enabled_providers: [input.providerID],
-  provider: {
-    [input.providerID]: {
-      name: input.name,
-      env: input.env,
-      npm: input.npm,
-      api: input.api,
-      models: { [input.model.id]: cloneModel(input.model) },
-      options: input.options,
-    },
-  },
-})
-
-const RECORDED_SCENARIOS = [
-  {
-    id: "openai-api-key",
-    name: "OpenAI API key",
-    providerID: ProviderV2.ID.openai,
-    modelID: "gpt-4.1-mini",
-    cassette: "session/native-openai-tool-loop",
-    protocol: "openai-responses",
-    tags: ["miaw", "native", "tool-loop"],
-    canRecord: () => Boolean(envValue("MIAW_RECORD_OPENAI_API_KEY", "OPENAI_API_KEY")),
-    config: (model) =>
-      providerConfig({
-        providerID: ProviderV2.ID.openai,
-        name: "OpenAI",
-        env: ["OPENAI_API_KEY"],
-        npm: "@ai-sdk/openai",
-        api: "https://api.openai.com/v1",
-        model,
-        options: {
-          apiKey: envValue("MIAW_RECORD_OPENAI_API_KEY", "OPENAI_API_KEY") ?? "fixture-openai-key",
-          baseURL: "https://api.openai.com/v1",
-        },
-      }),
-  },
-  {
-    id: "openai-oauth",
-    name: "OpenAI OAuth",
-    providerID: ProviderV2.ID.openai,
-    modelID: "gpt-5.5",
-    cassette: "session/native-openai-oauth-tool-loop",
-    protocol: "openai-responses",
-    tags: ["miaw", "native", "oauth", "tool-loop"],
-    canRecord: () => recordOpenAIOAuth() !== undefined,
-    recordAuth: recordOpenAIOAuth,
-    replayAuth: replayOpenAIOAuth,
-    stableID: "openai-oauth",
-    config: (model) =>
-      providerConfig({
-        providerID: ProviderV2.ID.openai,
-        name: "OpenAI",
-        env: ["OPENAI_API_KEY"],
-        npm: "@ai-sdk/openai",
-        api: "https://api.openai.com/v1",
-        model,
-        options: { baseURL: "https://api.openai.com/v1" },
-      }),
-  },
-  {
-    id: "miaw-proxy",
-    name: "Miaw proxy",
-    providerID: ProviderV2.ID.miaw,
-    modelID: "gpt-5.2-codex",
-    cassette: "session/native-zen-tool-loop",
-    protocol: "openai-responses",
-    tags: ["miaw", "zen", "native", "tool-loop"],
-    canRecord: () => Boolean(process.env.MIAW_RECORD_CONSOLE_TOKEN && process.env.MIAW_RECORD_ZEN_ORG_ID),
-    config: (model) =>
-      providerConfig({
-        providerID: ProviderV2.ID.miaw,
-        name: "Miaw Zen",
-        env: ["MIAW_CONSOLE_TOKEN"],
-        npm: "@ai-sdk/openai-compatible",
-        api: zenURL(process.env.MIAW_RECORD_ZEN_CONNECTION ?? "fixture"),
-        model,
-        options: {
-          apiKey: process.env.MIAW_RECORD_CONSOLE_TOKEN ?? "fixture-console-token",
-          headers: { "x-org-id": process.env.MIAW_RECORD_ZEN_ORG_ID ?? "fixture-org" },
-        },
-      }),
-  },
-  {
-    id: "anthropic-api-key",
-    name: "Anthropic API key",
-    providerID: ProviderV2.ID.anthropic,
-    modelID: "claude-haiku-4-5-20251001",
-    cassette: "session/native-anthropic-tool-loop",
-    protocol: "anthropic-messages",
-    tags: ["miaw", "native", "tool-loop"],
-    canRecord: () => Boolean(envValue("MIAW_RECORD_ANTHROPIC_API_KEY", "ANTHROPIC_API_KEY")),
-    config: (model) =>
-      providerConfig({
-        providerID: ProviderV2.ID.anthropic,
-        name: "Anthropic",
-        env: ["ANTHROPIC_API_KEY"],
-        npm: "@ai-sdk/anthropic",
-        api: "https://api.anthropic.com/v1",
-        model,
-        options: {
-          apiKey: envValue("MIAW_RECORD_ANTHROPIC_API_KEY", "ANTHROPIC_API_KEY") ?? "fixture-anthropic-key",
-          baseURL: "https://api.anthropic.com/v1",
-        },
-      }),
-  },
-] satisfies ReadonlyArray<RecordedScenario>
-
-const shouldRecord = process.env.RECORD === "true"
-const selectedScenarios = new Set(
-  (envValue("MIAW_RECORDED_SCENARIO", "RECORDED_PROVIDER") ?? "")
-    .split(",")
-    .map((item) => item.trim().toLowerCase())
-    .filter(Boolean),
-)
-
-function isSelected(scenario: RecordedScenario) {
-  if (selectedScenarios.size === 0) return true
-  return [scenario.id, scenario.name, scenario.providerID, scenario.cassette, ...scenario.tags]
-    .map((item) => item.toLowerCase())
-    .some((item) => selectedScenarios.has(item))
-}
-
-const canRun = (scenario: RecordedScenario) =>
-  shouldRecord
-    ? scenario.canRecord()
-    : HttpRecorderInternal.hasCassetteSync(scenario.cassette, { directory: FIXTURES_DIR })
-
-const recordError = (scenario: RecordedScenario) =>
-  scenario.id === "openai-oauth"
-    ? "Set MIAW_RECORD_OPENAI_AUTH to an OAuth auth JSON object in the recording environment."
-    : `Missing recording credentials for ${scenario.name}.`
-
-const redactRecordedBody = (body: string) =>
-  body
-    .replace(/wrk_[A-Z0-9]+/g, "wrk_redacted")
-    .replace(/"safety_identifier"\s*:\s*"user-[^"]+"/g, '"safety_identifier":"user_redacted"')
-    .replace(/"(access|access_token|refresh|refresh_token|accountId|account_id)"\s*:\s*"[^"]+"/g, '"$1":"redacted"')
-
-function authLayer(scenario: RecordedScenario) {
-  const replayAuth = shouldRecord ? scenario.recordAuth?.() : scenario.replayAuth
-  if (!replayAuth) return Auth.defaultLayer
-  return Layer.mock(Auth.Service)({
-    get: (providerID) => Effect.succeed(providerID === scenario.providerID ? replayAuth : undefined),
-    all: () => Effect.succeed({ [scenario.providerID]: replayAuth }),
-  })
-}
-
-async function loadFixture(providerID: string, modelID: string) {
-  const data = await modelsFixture
-  const provider = data[providerID]
-  if (!provider) throw new Error(`Missing provider in fixture: ${providerID}`)
-  const model = provider.models[modelID]
-  if (!model) throw new Error(`Missing model in fixture: ${modelID}`)
-  return model
-}
-
-const modelsFixture = Filesystem.readJson<Record<string, ModelsDev.Provider>>(
-  path.join(import.meta.dir, "../tool/fixtures/models-api.json"),
-)
-
-function recordedNativeLLMLayer(scenario: RecordedScenario) {
-  const auth = authLayer(scenario)
-  const provider = Provider.layer.pipe(
-    Layer.provide(FSUtil.defaultLayer),
-    Layer.provide(Env.defaultLayer),
-    Layer.provide(Config.defaultLayer),
-    Layer.provide(auth),
-    Layer.provide(Plugin.defaultLayer),
-    Layer.provide(ModelsDev.defaultLayer),
-    Layer.provide(RuntimeFlags.defaultLayer),
-  )
-  // Only the HTTP client is recorded; RequestExecutor and the miaw LLM stack remain real.
-  const metadata = {
-    provider: scenario.providerID,
-    protocol: scenario.protocol,
-    route: scenario.protocol,
-    tags: scenario.tags,
-  }
-  const redact = {
-    url: (url: string) => url.replace(/\/proxy\/connections\/[^/]+\/v1/, "/proxy/connections/{connection}/v1"),
-    body: redactRecordedBody,
-  }
-  const recordedHttp = shouldRecord
-    ? HttpRecorderInternal.cassetteLayer(scenario.cassette, {
-        directory: FIXTURES_DIR,
-        mode: "record",
-        metadata,
-        redactor: HttpRecorderInternal.Redactor.make(redact),
-      })
-    : HttpRecorder.http(scenario.cassette, { directory: FIXTURES_DIR, metadata, redact })
-  const recordedClient = LLMClient.layer.pipe(
-    Layer.provide(Layer.mergeAll(RequestExecutor.layer.pipe(Layer.provide(recordedHttp)), WebSocketExecutor.layer)),
-  )
-
-  return Layer.mergeAll(
-    provider,
-    LLM.layer.pipe(
-      Layer.provide(auth),
-      Layer.provide(Config.defaultLayer),
-      Layer.provide(provider),
-      Layer.provide(Plugin.defaultLayer),
-      Layer.provide(recordedClient),
-      Layer.provide(RuntimeFlags.layer({ experimentalNativeLlm: true })),
-    ),
-  )
-}
-
-const writeConfig = (directory: string, scenario: RecordedScenario, model: ModelsDev.Provider["models"][string]) =>
-  Effect.promise(() =>
-    Bun.write(
-      path.join(directory, "miaw.json"),
-      JSON.stringify({ $schema: "https://miaw/config.json", ...scenario.config(model) }),
-    ),
-  )
-
-const collect = (input: LLM.StreamInput) =>
-  Effect.gen(function* () {
-    const llm = yield* LLM.Service
-    return Array.from(yield* llm.stream(input).pipe(Stream.runCollect))
-  })
-
-const WEATHER_RESULT = { temperature: 22, condition: "sunny" } as const
-const WEATHER_SYSTEM =
-  "Use the get_weather tool exactly once to look up Paris, then reply with exactly: Paris is sunny."
-const WEATHER_USER = "What is the weather in Paris?"
-
-const weatherTool = tool({
-  description: "Get the current weather for a city.",
-  inputSchema: z.object({ city: z.string() }),
-  execute: async () => WEATHER_RESULT,
-})
-
-const toolRoundtrip = (
-  events: ReadonlyArray<LLMEvent>,
-  call: { readonly id: string; readonly name: string; readonly input: unknown },
-  result: JSONValue,
-): ModelMessage[] => [
-  {
-    role: "assistant",
-    content: [
-      ...events.filter(LLMEvent.is.reasoningEnd).map((part) => ({
-        type: "reasoning" as const,
-        text: events
-          .filter(LLMEvent.is.reasoningDelta)
-          .filter((event) => event.id === part.id)
-          .map((event) => event.text)
-          .join(""),
-        providerMetadata: part.providerMetadata,
-      })),
-      { type: "tool-call", toolCallId: call.id, toolName: call.name, input: call.input },
-    ],
-  },
-  {
-    role: "tool",
-    content: [
-      { type: "tool-result", toolCallId: call.id, toolName: call.name, output: { type: "json", value: result } },
-    ],
-  },
-]
-
-const driveToolLoop = (scenario: RecordedScenario) =>
-  Effect.gen(function* () {
-    const test = yield* TestInstance
-    const model = yield* Effect.promise(() => loadFixture(scenario.providerID, scenario.modelID))
-    yield* writeConfig(test.directory, scenario, model)
-
-    const stableID = scenario.stableID ?? scenario.providerID
-    const sessionID = SessionID.make(`session-recorded-${stableID}-loop`)
-    const modelID = ModelV2.ID.make(model.id)
-    const agent = {
-      name: "test",
-      mode: "primary",
-      prompt: "Answer using tools when appropriate.",
-      options: {},
-      permission: [{ permission: "*", pattern: "*", action: "allow" }],
-      temperature: 0,
-    } satisfies Agent.Info
-    const provider = yield* Provider.Service
-    const resolved = yield* provider.getModel(scenario.providerID, modelID)
-
-    const userMessage = { role: "user", content: WEATHER_USER } satisfies ModelMessage
-    const base = {
-      user: {
-        id: MessageID.make(`msg_user-recorded-${stableID}-loop`),
-        sessionID,
-        role: "user",
-        time: { created: 0 },
-        agent: agent.name,
-        model: { providerID: scenario.providerID, modelID },
-      } satisfies SessionV1.User,
-      sessionID,
-      model: resolved,
-      agent,
-      system: [WEATHER_SYSTEM],
-      tools: { get_weather: weatherTool },
-    }
-
-    const turn1 = yield* collect({ ...base, messages: [userMessage] })
-    const toolCall = turn1.find(LLMEvent.is.toolCall)
-    expect(toolCall).toBeDefined()
-    expect(turn1.find(LLMEvent.is.toolResult)).toBeDefined()
-    expect(toolCall!.name).toBe("get_weather")
-    expect(toolCall!.input).toMatchObject({ city: expect.stringMatching(/Paris/i) })
-    expect(turn1.filter(LLMEvent.is.stepFinish)).toHaveLength(1)
-
-    const turn2 = yield* collect({
-      ...base,
-      messages: [userMessage, ...toolRoundtrip(turn1, toolCall!, WEATHER_RESULT)],
-    })
-
-    expect(LLMResponse.text({ events: turn2 })).toMatch(/Paris is sunny/i)
-    expect(turn2.filter(LLMEvent.is.finish)).toHaveLength(1)
-    expect(turn2.filter(LLMEvent.is.toolCall)).toHaveLength(0)
-  })
-
-describe("session.llm native recorded", () => {
-  for (const scenario of RECORDED_SCENARIOS.filter(isSelected)) {
-    if (!canRun(scenario)) {
-      if (shouldRecord && scenario.recordAuth && selectedScenarios.size > 0) {
-        test(`${scenario.name}: drives a tool loop to a final text answer`, () => {
-          throw new Error(recordError(scenario))
-        })
-        continue
-      }
-      test.skip(`${scenario.name}: drives a tool loop to a final text answer`, () => {})
-      continue
-    }
-    const it = testEffect(recordedNativeLLMLayer(scenario))
-    it.instance(`${scenario.name}: drives a tool loop to a final text answer`, () => driveToolLoop(scenario))
-  }
-})