@neurocode-ai/core 1.18.8

package/test/session-runner-model.test.ts

@@ -0,0 +1,347 @@
+import { describe, expect } from "bun:test"
+import { LLM } from "@neurocode-ai/llm"
+import { LLMClient } from "@neurocode-ai/llm/route"
+import { DateTime, Effect } from "effect"
+import { Headers } from "effect/unstable/http"
+import { Credential } from "@neurocode-ai/core/credential"
+import { Integration } from "@neurocode-ai/core/integration"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { ProjectV2 } from "@neurocode-ai/core/project"
+import { SessionRunnerModel } from "@neurocode-ai/core/session/runner/model"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { it } from "./lib/effect"
+
+type Api =
+  | {
+      readonly type: "aisdk"
+      readonly package: string
+      readonly url?: string
+      readonly settings?: Record<string, unknown>
+    }
+  | { readonly type: "native"; readonly url?: string; readonly settings: Record<string, unknown> }
+
+const model = (api: Api, variants: ModelV2.Info["variants"] = []) =>
+  ModelV2.Info.make({
+    id: ModelV2.ID.make("test-model"),
+    providerID: ProviderV2.ID.make("test-provider"),
+    name: "Test model",
+    api: { id: ModelV2.ID.make("api-test-model"), ...api },
+    capabilities: { tools: true, input: ["text"], output: ["text"] },
+    request: {
+      headers: { "x-test": "header" },
+      body: { apiKey: "secret", custom_extension: { enabled: true } },
+    },
+    variants,
+    time: { released: 0 },
+    cost: [],
+    status: "active",
+    enabled: true,
+    limit: { context: 100, output: 20 },
+  })
+
+describe("SessionRunnerModel", () => {
+  it.effect("maps catalog OpenAI AI SDK models into native Responses routes", () =>
+    Effect.gen(function* () {
+      const resolved = yield* SessionRunnerModel.fromCatalogModel(
+        model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
+      )
+
+      expect(resolved).toMatchObject({ id: "api-test-model", provider: "test-provider" })
+      expect(resolved.route).toMatchObject({
+        id: "openai-responses",
+        endpoint: { baseURL: "https://openai.example/v1" },
+        defaults: {
+          headers: { "x-test": "header" },
+          limits: { context: 100, output: 20 },
+          http: { body: { custom_extension: { enabled: true } } },
+        },
+      })
+    }),
+  )
+
+  it.effect("keeps catalog apiKey credentials out of provider JSON", () =>
+    Effect.gen(function* () {
+      const resolved = yield* SessionRunnerModel.fromCatalogModel(
+        model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
+      )
+      const prepared = yield* LLMClient.prepare(LLM.request({ model: resolved, prompt: "Hello" }))
+
+      expect(JSON.stringify(prepared.body)).not.toContain("apiKey")
+      expect(JSON.stringify(prepared.body)).not.toContain("secret")
+    }),
+  )
+
+  it.effect("uses merged API settings for OpenAI-compatible auth and request defaults", () =>
+    Effect.gen(function* () {
+      const resolved = yield* SessionRunnerModel.fromCatalogModel(
+        ModelV2.Info.make({
+          ...model({
+            type: "aisdk",
+            package: "@ai-sdk/openai-compatible",
+            url: "https://compatible.example/v1",
+            settings: { apiKey: "settings-secret", compatibility: "strict" },
+          }),
+          request: { headers: {}, body: {} },
+        }),
+      )
+      const request = LLM.request({ model: resolved, prompt: "Hello" })
+      const headers = yield* resolved.route.auth.apply({
+        request,
+        method: "POST",
+        url: "https://compatible.example/v1/chat/completions",
+        body: "{}",
+        headers: Headers.empty,
+      })
+
+      expect(headers.authorization).toBe("Bearer settings-secret")
+      expect(resolved.route.defaults.http?.body).toEqual({})
+    }),
+  )
+
+  it.effect("overlays selected OpenAI Session variant bodies", () =>
+    Effect.gen(function* () {
+      const catalog = model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }, [
+        {
+          id: ModelV2.VariantID.make("high"),
+          headers: { "x-variant": "high" },
+          body: {
+            store: false,
+            service_tier: "priority",
+            temperature: 0.2,
+            reasoning: { effort: "high" },
+          },
+        },
+      ])
+      const session = SessionV2.Info.make({
+        id: SessionV2.ID.make("ses_model_variant"),
+        projectID: ProjectV2.ID.global,
+        title: "test",
+        model: {
+          id: catalog.id,
+          providerID: catalog.providerID,
+          variant: ModelV2.VariantID.make("high"),
+        },
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+        location: { directory: AbsolutePath.make("/project") },
+      })
+
+      const resolved = yield* SessionRunnerModel.resolve(session, catalog)
+
+      expect(resolved.route.defaults.headers).toMatchObject({ "x-test": "header", "x-variant": "high" })
+      expect(resolved.route.defaults.http?.body).toEqual({
+        custom_extension: { enabled: true },
+        store: false,
+        service_tier: "priority",
+        temperature: 0.2,
+        reasoning: { effort: "high" },
+      })
+    }),
+  )
+
+  it.effect("overlays selected OpenAI-compatible Session variant bodies", () =>
+    Effect.gen(function* () {
+      const catalog = model(
+        { type: "aisdk", package: "@ai-sdk/openai-compatible", url: "https://compatible.example/v1" },
+        [
+          {
+            id: ModelV2.VariantID.make("high"),
+            headers: {},
+            body: { store: false, reasoning_effort: "high" },
+          },
+        ],
+      )
+      const session = SessionV2.Info.make({
+        id: SessionV2.ID.make("ses_compatible_variant"),
+        projectID: ProjectV2.ID.global,
+        title: "test",
+        model: { id: catalog.id, providerID: catalog.providerID, variant: ModelV2.VariantID.make("high") },
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+        location: { directory: AbsolutePath.make("/project") },
+      })
+
+      const resolved = yield* SessionRunnerModel.resolve(session, catalog)
+
+      expect(resolved.route.defaults.http?.body).toEqual({
+        custom_extension: { enabled: true },
+        store: false,
+        reasoning_effort: "high",
+      })
+    }),
+  )
+
+  it.effect("rejects an explicit unavailable Session variant during model resolution", () =>
+    Effect.gen(function* () {
+      const catalog = model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" })
+      const session = SessionV2.Info.make({
+        id: SessionV2.ID.make("ses_model_variant_unavailable"),
+        projectID: ProjectV2.ID.global,
+        title: "test",
+        model: {
+          id: catalog.id,
+          providerID: catalog.providerID,
+          variant: ModelV2.VariantID.make("unknown"),
+        },
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+        location: { directory: AbsolutePath.make("/project") },
+      })
+
+      const failure = yield* SessionRunnerModel.resolve(session, catalog).pipe(Effect.flip)
+
+      expect(failure).toMatchObject({
+        _tag: "SessionRunnerModel.VariantUnavailableError",
+        providerID: "test-provider",
+        modelID: "test-model",
+        variant: "unknown",
+      })
+      expect(failure.message).toBe("Variant unavailable for test-provider/test-model: unknown")
+    }),
+  )
+
+  it.effect("overlays selected Anthropic Session variant bodies", () =>
+    Effect.gen(function* () {
+      const catalog = model({ type: "aisdk", package: "@ai-sdk/anthropic", url: "https://anthropic.example/v1" }, [
+        {
+          id: ModelV2.VariantID.make("high"),
+          headers: {},
+          body: { thinking: { type: "enabled", budget_tokens: 12000 } },
+        },
+      ])
+      const session = SessionV2.Info.make({
+        id: SessionV2.ID.make("ses_anthropic_variant"),
+        projectID: ProjectV2.ID.global,
+        title: "test",
+        model: { id: catalog.id, providerID: catalog.providerID, variant: ModelV2.VariantID.make("high") },
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+        location: { directory: AbsolutePath.make("/project") },
+      })
+
+      const resolved = yield* SessionRunnerModel.resolve(session, catalog)
+
+      expect(resolved.route.defaults.http?.body).toEqual({
+        custom_extension: { enabled: true },
+        thinking: { type: "enabled", budget_tokens: 12000 },
+      })
+    }),
+  )
+
+  it.effect("maps catalog Anthropic AI SDK models into native routes", () =>
+    Effect.gen(function* () {
+      const resolved = yield* SessionRunnerModel.fromCatalogModel(
+        model({ type: "aisdk", package: "@ai-sdk/anthropic", url: "https://anthropic.example/v1" }),
+      )
+
+      expect(resolved.route).toMatchObject({
+        id: "anthropic-messages",
+        endpoint: { baseURL: "https://anthropic.example/v1" },
+      })
+    }),
+  )
+
+  it.effect("uses resolved credentials for bearer auth", () =>
+    Effect.gen(function* () {
+      const resolved = yield* SessionRunnerModel.fromCatalogModel(
+        ModelV2.Info.make({
+          ...model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
+          request: { headers: {}, body: {} },
+        }),
+        Credential.Key.make({ type: "key", key: "secret" }),
+      )
+      const request = LLM.request({ model: resolved, prompt: "Hello" })
+      const headers = yield* resolved.route.auth.apply({
+        request,
+        method: "POST",
+        url: "https://openai.example/v1/responses",
+        body: "{}",
+        headers: Headers.empty,
+      })
+
+      expect(headers.authorization).toBe("Bearer secret")
+    }),
+  )
+
+  it.effect("prefers stored credentials over configured auth", () =>
+    Effect.gen(function* () {
+      const credential = Credential.Key.make({ type: "key", key: "stored-secret", metadata: { tenant: "work" } })
+      const resolved = yield* SessionRunnerModel.fromCatalogModel(
+        ModelV2.Info.make({
+          ...model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
+          request: { headers: {}, body: { apiKey: "configured-secret" } },
+        }),
+        credential,
+      )
+      const headers = yield* resolved.route.auth.apply({
+        request: LLM.request({ model: resolved, prompt: "Hello" }),
+        method: "POST",
+        url: "https://openai.example/v1/responses",
+        body: "{}",
+        headers: Headers.empty,
+      })
+
+      expect(headers.authorization).toBe("Bearer stored-secret")
+      expect(resolved.route.defaults.http?.body).toEqual({ tenant: "work" })
+    }),
+  )
+
+  it.effect("does not project OAuth account metadata into the request body", () =>
+    Effect.gen(function* () {
+      const resolved = yield* SessionRunnerModel.fromCatalogModel(
+        ModelV2.Info.make({
+          ...model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
+          request: { headers: {}, body: {} },
+        }),
+        Credential.OAuth.make({
+          type: "oauth",
+          methodID: Integration.MethodID.make("device"),
+          access: "secret",
+          refresh: "refresh",
+          expires: Date.now() + 60_000,
+          metadata: { server: "https://console.example", orgID: "org_123" },
+        }),
+      )
+
+      expect(resolved.route.defaults.http?.body).toEqual({})
+    }),
+  )
+
+  it.effect("rejects catalog APIs without a native route", () =>
+    Effect.gen(function* () {
+      const failure = yield* SessionRunnerModel.fromCatalogModel(
+        model({ type: "aisdk", package: "@ai-sdk/google", url: "https://google.example/v1" }),
+      ).pipe(Effect.flip)
+
+      expect(failure).toMatchObject({
+        _tag: "SessionRunnerModel.UnsupportedApiError",
+        providerID: "test-provider",
+        modelID: "test-model",
+        api: "aisdk:@ai-sdk/google",
+      })
+      expect(failure.message).toBe("Unsupported API for test-provider/test-model: aisdk:@ai-sdk/google")
+    }),
+  )
+
+  it.effect("reports whether a catalog model has a supported native route", () =>
+    Effect.sync(() => {
+      expect(
+        SessionRunnerModel.supported(
+          model({ type: "aisdk", package: "@ai-sdk/openai", url: "https://openai.example/v1" }),
+        ),
+      ).toBe(true)
+      expect(
+        SessionRunnerModel.supported(
+          model({ type: "aisdk", package: "@ai-sdk/google", url: "https://google.example/v1" }),
+        ),
+      ).toBe(false)
+      expect(SessionRunnerModel.supported(model({ type: "native", settings: {} }))).toBe(false)
+    }),
+  )
+})

package/test/session-runner-recorded.test.ts

@@ -0,0 +1,193 @@
+import { HttpRecorder } from "@neurocode-ai/http-recorder"
+import { HttpRecorderInternal } from "@neurocode-ai/http-recorder/internal"
+import * as OpenAIChat from "@neurocode-ai/llm/protocols/openai-chat"
+import { Auth, LLMClient, RequestExecutor } from "@neurocode-ai/llm/route"
+import { Database } from "@neurocode-ai/core/database/database"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { LayerNodePlatform } from "@neurocode-ai/core/effect/app-node-platform"
+import { LayerNode } from "@neurocode-ai/core/effect/layer-node"
+import { EventV2 } from "@neurocode-ai/core/event"
+import { EventTable } from "@neurocode-ai/core/event/sql"
+import { PermissionV2 } from "@neurocode-ai/core/permission"
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { Config } from "@neurocode-ai/core/config"
+import { Project } from "@neurocode-ai/core/project"
+import { ProjectTable } from "@neurocode-ai/core/project/sql"
+import { AbsolutePath } from "@neurocode-ai/core/schema"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { Snapshot } from "@neurocode-ai/core/snapshot"
+import { Prompt } from "@neurocode-ai/core/session/prompt"
+import { SessionProjector } from "@neurocode-ai/core/session/projector"
+import { SessionExecution } from "@neurocode-ai/core/session/execution"
+import { SessionRunCoordinator } from "@neurocode-ai/core/session/run-coordinator"
+import { SessionRunner } from "@neurocode-ai/core/session/runner"
+import * as SessionRunnerLLM from "@neurocode-ai/core/session/runner/llm"
+import { SessionRunnerModel } from "@neurocode-ai/core/session/runner/model"
+import { ToolRegistry } from "@neurocode-ai/core/tool/registry"
+import { ToolOutputStore } from "@neurocode-ai/core/tool-output-store"
+import { SessionTable } from "@neurocode-ai/core/session/sql"
+import { SessionStore } from "@neurocode-ai/core/session/store"
+import { Location } from "@neurocode-ai/core/location"
+import { SystemContextRegistry } from "@neurocode-ai/core/system-context/registry"
+import { SystemContext } from "@neurocode-ai/core/system-context"
+import { SkillGuidance } from "@neurocode-ai/core/skill/guidance"
+import { ReferenceGuidance } from "@neurocode-ai/core/reference/guidance"
+import { describe, expect } from "bun:test"
+import { eq } from "drizzle-orm"
+import { Effect, Layer } from "effect"
+import path from "node:path"
+import { testEffect } from "./lib/effect"
+
+const cassette =
+  process.env.RECORD === "true"
+    ? HttpRecorderInternal.cassetteLayer("session-runner/openai-chat-streams-text", {
+        directory: path.resolve(import.meta.dir, "fixtures/recordings"),
+        mode: "record",
+      })
+    : HttpRecorder.http("session-runner/openai-chat-streams-text", {
+        directory: path.resolve(import.meta.dir, "fixtures/recordings"),
+      })
+const executor = RequestExecutor.layer.pipe(Layer.provide(cassette))
+const client = LLMClient.layer.pipe(Layer.provide(executor))
+const permission = Layer.succeed(
+  PermissionV2.Service,
+  PermissionV2.Service.of({
+    assert: () => Effect.die("unused"),
+    ask: () => Effect.die("unused"),
+    reply: () => Effect.die("unused"),
+    get: () => Effect.die("unused"),
+    forSession: () => Effect.die("unused"),
+    list: () => Effect.die("unused"),
+  }),
+)
+const model = OpenAIChat.route
+  .with({
+    endpoint: { baseURL: "https://api.openai.com/v1" },
+    auth: Auth.bearer(process.env.OPENAI_API_KEY ?? "fixture"),
+    generation: { maxTokens: 20, temperature: 0 },
+  })
+  .model({ id: "gpt-4o-mini" })
+const models = SessionRunnerModel.layerWith(() => Effect.succeed(model))
+const systemContext = AppNodeBuilder.build(SystemContextRegistry.node)
+const skillGuidance = Layer.mock(SkillGuidance.Service, { load: () => Effect.succeed(SystemContext.empty) })
+const referenceGuidance = Layer.mock(ReferenceGuidance.Service, { load: () => Effect.succeed(SystemContext.empty) })
+const config = Layer.succeed(Config.Service, Config.Service.of({ entries: () => Effect.succeed([]) }))
+const runnerLayer = AppNodeBuilder.build(SessionRunnerLLM.node, [
+  [Snapshot.node, Snapshot.noopLayer],
+  [LayerNodePlatform.llmClient, client],
+  [SessionRunnerModel.node, models],
+  [SystemContextRegistry.node, systemContext],
+  [Location.node, Location.boundNode({ directory: AbsolutePath.make("/project") })],
+  [SkillGuidance.node, skillGuidance],
+  [ReferenceGuidance.node, referenceGuidance],
+  [Config.node, config],
+  [PermissionV2.node, permission],
+  [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
+])
+const execution = Layer.effect(
+  SessionExecution.Service,
+  Effect.gen(function* () {
+    const sessionRunner = yield* SessionRunner.Service
+    const coordinator = yield* SessionRunCoordinator.make<SessionV2.ID, SessionRunner.RunError>({
+      drain: (sessionID, force) => sessionRunner.run({ sessionID, force }),
+    })
+    return SessionExecution.Service.of({
+      active: coordinator.active,
+      resume: coordinator.run,
+      wake: coordinator.wake,
+      interrupt: coordinator.interrupt,
+    })
+  }),
+).pipe(Layer.provide(runnerLayer))
+const it = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([
+      Database.node,
+      EventV2.node,
+      SessionProjector.node,
+      SessionStore.node,
+      AgentV2.node,
+      ToolRegistry.node,
+      SessionRunnerModel.node,
+      SystemContextRegistry.node,
+      SkillGuidance.node,
+      ReferenceGuidance.node,
+      Config.node,
+      Snapshot.node,
+      SessionRunnerLLM.node,
+      SessionV2.node,
+    ]),
+    [
+      [LayerNodePlatform.llmClient, client],
+      [PermissionV2.node, permission],
+      [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
+      [SessionRunnerModel.node, models],
+      [SystemContextRegistry.node, systemContext],
+      [Location.node, Location.boundNode({ directory: AbsolutePath.make("/project") })],
+      [SkillGuidance.node, skillGuidance],
+      [ReferenceGuidance.node, referenceGuidance],
+      [Config.node, config],
+      [Snapshot.node, Snapshot.noopLayer],
+      [SessionExecution.node, execution],
+    ],
+  ),
+)
+const sessionID = SessionV2.ID.make("ses_runner_recorded")
+
+describe("SessionRunnerLLM recorded", () => {
+  it.effect("executes one recorded V2 prompt through the recorded HTTP transport", () =>
+    Effect.gen(function* () {
+      const { db } = yield* Database.Service
+      yield* db
+        .insert(ProjectTable)
+        .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+        .onConflictDoNothing()
+        .run()
+        .pipe(Effect.orDie)
+      yield* db
+        .insert(SessionTable)
+        .values({
+          id: sessionID,
+          project_id: Project.ID.global,
+          slug: "test",
+          directory: "/project",
+          title: "test",
+          version: "test",
+        })
+        .onConflictDoNothing()
+        .run()
+        .pipe(Effect.orDie)
+      const session = yield* SessionV2.Service
+      const prompt = yield* session.prompt({
+        sessionID,
+        prompt: Prompt.make({ text: "Say hello in one short sentence." }),
+        resume: false,
+      })
+
+      yield* session.resume(sessionID)
+
+      const messages = yield* session.context(sessionID)
+      expect(messages).toHaveLength(2)
+      expect(messages[0]).toMatchObject({ id: prompt.id, type: "user", text: "Say hello in one short sentence." })
+      expect(messages[1]).toMatchObject({ type: "assistant", agent: "build", finish: "stop" })
+      expect(messages[1]?.type === "assistant" ? messages[1].content : []).toMatchObject([
+        { type: "text", text: "Hello!" },
+      ])
+      expect(
+        (yield* db
+          .select({ type: EventTable.type })
+          .from(EventTable)
+          .where(eq(EventTable.aggregate_id, sessionID))
+          .orderBy(EventTable.seq)
+          .all()).map((event) => event.type),
+      ).toEqual([
+        "session.next.prompt.admitted.1",
+        "session.next.prompted.1",
+        "session.next.step.started.1",
+        "session.next.text.started.1",
+        "session.next.text.ended.1",
+        "session.next.step.ended.2",
+      ])
+    }),
+  )
+})

package/test/session-runner-tool-events.test.ts

@@ -0,0 +1,136 @@
+import { expect, test } from "bun:test"
+import { Effect, Schema, Stream } from "effect"
+import { LLMEvent } from "@neurocode-ai/llm"
+import { EventV2 } from "@neurocode-ai/core/event"
+import { SessionEvent } from "@neurocode-ai/core/session/event"
+import { SessionMessage } from "@neurocode-ai/core/session/message"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { ModelV2 } from "@neurocode-ai/core/model"
+import { ProviderV2 } from "@neurocode-ai/core/provider"
+import { createLLMEventPublisher } from "@neurocode-ai/core/session/runner/publish-llm-event"
+
+const sessionID = SessionV2.ID.make("ses_tool_event_test")
+const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB"
+
+const capture = () => {
+  const published: Array<{ readonly type: string; readonly data: unknown }> = []
+  const events = EventV2.Service.of({
+    publish: (definition, data) =>
+      Effect.sync(() => {
+        const event = { id: EventV2.ID.create(), type: definition.type, data } as EventV2.Payload<typeof definition>
+        published.push({
+          type: definition.durable
+            ? EventV2.versionedType(definition.type, definition.durable.version)
+            : definition.type,
+          data,
+        })
+        return event
+      }),
+    subscribe: () => Stream.empty,
+    all: () => Stream.empty,
+    durable: () => Stream.empty,
+    listen: () => Effect.succeed(Effect.void),
+    project: () => Effect.void,
+    replay: () => Effect.void,
+    replayAll: () => Effect.succeed(undefined),
+    remove: () => Effect.void,
+    claim: () => Effect.void,
+  })
+  return {
+    published,
+    publisher: createLLMEventPublisher(events, {
+      sessionID,
+      agent: "build",
+      model: {
+        id: ModelV2.ID.make("model"),
+        providerID: ProviderV2.ID.make("provider"),
+      },
+    }),
+  }
+}
+
+const call = LLMEvent.toolCall({ id: "call-image", name: "read", input: { path: "pixel.png" } })
+const result = LLMEvent.toolResult({
+  id: "call-image",
+  name: "read",
+  result: {
+    type: "content",
+    value: [
+      { type: "text", text: "Image read successfully" },
+      { type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png", name: "pixel.png" },
+    ],
+  },
+  output: {
+    structured: { type: "media", mime: "image/png" },
+    content: [
+      { type: "text", text: "Image read successfully" },
+      { type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png", name: "pixel.png" },
+    ],
+  },
+})
+
+test("local tool success serializes media base64 once and reconstructs from structured content", async () => {
+  const { published, publisher } = capture()
+  await Effect.runPromise(publisher.publish(call))
+  await Effect.runPromise(publisher.publish(result))
+
+  const success = published.find((event) => event.type === "session.next.tool.success.1")
+  expect(success).toBeDefined()
+  const serialized = JSON.stringify(success)
+  expect(serialized.split(base64)).toHaveLength(2)
+  expect(success?.data).not.toHaveProperty("result")
+
+  expect(success?.data).toMatchObject({
+    content: [
+      { type: "text", text: "Image read successfully" },
+      { type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png" },
+    ],
+  })
+})
+
+test("provider-executed success retains its compatibility result", async () => {
+  const { published, publisher } = capture()
+  await Effect.runPromise(publisher.publish(LLMEvent.toolCall({ ...call, providerExecuted: true })))
+  await Effect.runPromise(publisher.publish(LLMEvent.toolResult({ ...result, providerExecuted: true })))
+  const success = published.find((event) => event.type === "session.next.tool.success.1")
+  expect(success?.data).toHaveProperty("result")
+})
+
+test("binary failure emits no success event", async () => {
+  const { published, publisher } = capture()
+  await Effect.runPromise(publisher.publish(call))
+  await Effect.runPromise(
+    publisher.publish(
+      LLMEvent.toolResult({
+        id: call.id,
+        name: call.name,
+        result: { type: "error", value: "Cannot read binary file" },
+      }),
+    ),
+  )
+  expect(published.some((event) => event.type === "session.next.tool.success.1")).toBe(false)
+  expect(published.some((event) => event.type === "session.next.tool.failed.1")).toBe(true)
+})
+
+test("old success event data containing result still decodes", () => {
+  const decoded = Schema.decodeUnknownSync(SessionEvent.Tool.Success.data)({
+    sessionID,
+    timestamp: Date.now(),
+    assistantMessageID: SessionMessage.ID.create(),
+    callID: "call-old",
+    structured: { type: "media", mime: "image/png" },
+    content: [{ type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png" }],
+    result: { type: "content", value: [{ type: "file", uri: `data:image/png;base64,${base64}`, mime: "image/png" }] },
+    provider: { executed: false },
+  })
+  expect(decoded.result).toMatchObject({ type: "content" })
+})
+
+test("step finish records settlement without publishing step ended", async () => {
+  const { published, publisher } = capture()
+  await Effect.runPromise(publisher.publish(LLMEvent.stepStart({ index: 0 })))
+  await Effect.runPromise(publisher.publish(LLMEvent.stepFinish({ index: 0, reason: "stop" })))
+
+  expect(published.some((event) => event.type === "session.next.step.ended.2")).toBe(false)
+  expect(publisher.stepSettlement()).toMatchObject({ finish: "stop" })
+})