lmin/zmo-cli
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

feat(core): add embedded v2 session runtime and tool foundation (#30632)

Browse Source
This commit is contained in:
Kit Langton
2026-06-03 23:02:17 -04:00
committed by GitHub
parent c35267776a
commit 76ee87ead8
215 changed files with 31344 additions and 3278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
packages/opencode/test/session/llm-native-recorded.test.ts
View File

@@ -1,14 +1,11 @@
import { NodeFileSystem } from "@effect/platform-node"
import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
import { SessionV1 } from "@opencode-ai/core/v1/session"
import { FSUtil } from "@opencode-ai/core/fs-util"
import { ModelsDev } from "@opencode-ai/core/models-dev"
import { LocationServiceMap } from "@opencode-ai/core/location-layer"
import { HttpRecorder, Redactor } from "@opencode-ai/http-recorder"
import { describe, expect, test } from "bun:test"
import { tool, type ModelMessage, type JSONValue } from "ai"
import { Effect, Layer, Option, Schema, Stream } from "effect"
import { FetchHttpClient } from "effect/unstable/http"
import path from "node:path"
import z from "zod"
import { Auth } from "@/auth"
@@ -280,13 +277,10 @@ function recordedNativeLLMLayer(scenario: RecordedScenario) {
Layer.provide(Plugin.defaultLayer),
Layer.provide(ModelsDev.defaultLayer),
Layer.provide(RuntimeFlags.defaultLayer),
Layer.provide(LocationServiceMap.layer),
)
// Only the HTTP client is recorded; RequestExecutor and the opencode LLM stack remain real.
const recordedClient = LLMClient.layer.pipe(
Layer.provide(Layer.mergeAll(RequestExecutor.layer, WebSocketExecutor.layer)),
Layer.provide(
HttpRecorder.recordingLayer(scenario.cassette, {
const recordedHttp = HttpRecorder.cassetteLayer(scenario.cassette, {
directory: FIXTURES_DIR,
mode: shouldRecord ? "record" : "replay",
metadata: {
provider: scenario.providerID,
@@ -295,7 +289,10 @@ function recordedNativeLLMLayer(scenario: RecordedScenario) {
tags: scenario.tags,
},
redactor: recordingRedactor,
}).pipe(Layer.provide(FetchHttpClient.layer)),
})
const recordedClient = LLMClient.layer.pipe(
Layer.provide(
Layer.mergeAll(RequestExecutor.layer.pipe(Layer.provide(recordedHttp)), WebSocketExecutor.layer),
),
)
@@ -307,9 +304,6 @@ function recordedNativeLLMLayer(scenario: RecordedScenario) {
Layer.provide(provider),
Layer.provide(Plugin.defaultLayer),
Layer.provide(recordedClient),
Layer.provide(
HttpRecorder.Cassette.fileSystem({ directory: FIXTURES_DIR }).pipe(Layer.provide(NodeFileSystem.layer)),
),
Layer.provide(RuntimeFlags.layer({ experimentalNativeLlm: true })),
),
)

66
packages/opencode/test/session/llm-native.test.ts
View File

@@ -1,8 +1,8 @@
import { describe, expect, test } from "bun:test"
import { ToolFailure } from "@opencode-ai/llm"
import { LLMClient, RequestExecutor, WebSocketExecutor } from "@opencode-ai/llm/route"
import { LLMEvent, ToolFailure } from "@opencode-ai/llm"
import { LLMClient, RequestExecutor, WebSocketExecutor, type LLMClientShape } from "@opencode-ai/llm/route"
import { jsonSchema, tool, type ModelMessage, type Tool } from "ai"
import { Effect, Layer, Stream } from "effect"
import { Effect, Fiber, Layer, Stream } from "effect"
import { LLMNative } from "@/session/llm/native-request"
import { LLMNativeRuntime } from "@/session/llm/native-runtime"
import type { Provider } from "@/provider/provider"
@@ -535,6 +535,66 @@ describe("session.llm-native.request", () => {
}),
)
it.effect("emits native tool calls before overlapping local settlements complete", () =>
Effect.gen(function* () {
const observed: string[] = []
const started: string[] = []
let release: (() => void) | undefined
let notifyStarted: (() => void) | undefined
const gate = new Promise<void>((resolve) => {
release = resolve
})
const bothStarted = new Promise<void>((resolve) => {
notifyStarted = resolve
})
const lookup = {
description: "Lookup data",
inputSchema: jsonSchema({ type: "object" }),
execute: async (_args: unknown, options: { toolCallId: string }) => {
started.push(options.toolCallId)
if (started.length === 2) notifyStarted?.()
await gate
return { output: options.toolCallId }
},
} satisfies Tool
const llmClient = {
prepare: () => Effect.die("unused"),
stream: () =>
Stream.fromIterable([
LLMEvent.toolCall({ id: "call-1", name: "lookup", input: {} }),
LLMEvent.toolCall({ id: "call-2", name: "lookup", input: {} }),
LLMEvent.finish({ reason: "tool-calls" }),
]),
generate: () => Effect.die("unused"),
} as LLMClientShape
const native = LLMNativeRuntime.stream({
model: baseModel,
provider: providerInfo,
auth: undefined,
llmClient,
messages: [],
tools: { lookup },
headers: {},
abort: new AbortController().signal,
})
expect(native.type).toBe("supported")
if (native.type === "unsupported") throw new Error(native.reason)
const fiber = yield* native.stream.pipe(
Stream.runForEach((event) => Effect.sync(() => observed.push(event.type))),
Effect.forkScoped,
)
yield* Effect.promise(() => bothStarted)
expect(started).toEqual(["call-1", "call-2"])
expect(observed).toEqual(["tool-call", "tool-call", "finish"])
release?.()
yield* Fiber.join(fiber)
expect(observed).toEqual(["tool-call", "tool-call", "finish", "tool-result", "tool-result"])
}),
)
it.effect("compiles through the native OpenAI Responses route", () =>
expectOpenAIResponsesRequest({
history: [storedSession.user("hello")],

164
packages/opencode/test/session/processor-effect.test.ts
View File

@@ -4,7 +4,7 @@ import { Database } from "@opencode-ai/core/database/database"
import { EventV2Bridge } from "@/event-v2-bridge"
import { expect } from "bun:test"
import { tool } from "ai"
import { Cause, Effect, Exit, Fiber, Layer } from "effect"
import { Cause, Effect, Exit, Fiber, Layer, Stream } from "effect"
import path from "path"
import z from "zod"
import type { Agent } from "../../src/agent/agent"
@@ -25,11 +25,13 @@ import { SessionSummary } from "../../src/session/summary"
import { Snapshot } from "../../src/snapshot"
import * as Log from "@opencode-ai/core/util/log"
import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
import { provideTmpdirServer } from "../fixture/fixture"
import { provideTmpdirInstance, provideTmpdirServer } from "../fixture/fixture"
import { testEffect } from "../lib/effect"
import { raw, reply, TestLLMServer } from "../lib/llm-server"
import { RuntimeFlags } from "@/effect/runtime-flags"
import { ProviderV2 } from "@opencode-ai/core/provider"
import { SessionEvent } from "@opencode-ai/core/session/event"
import { LLMEvent } from "@opencode-ai/llm"
void Log.init({ print: false })
@@ -198,6 +200,58 @@ const env = Layer.mergeAll(
const it = testEffect(env)
const providerErrorLLM = Layer.succeed(
LLM.Service,
LLM.Service.of({
stream: () =>
Stream.make(
LLMEvent.stepStart({ index: 0 }),
LLMEvent.toolInputStart({ id: "call-1", name: "lookup" }),
LLMEvent.toolInputEnd({ id: "call-1", name: "lookup" }),
LLMEvent.toolCall({ id: "call-1", name: "lookup", input: {}, providerExecuted: true }),
LLMEvent.toolResult({
id: "call-1",
name: "lookup",
result: { type: "error", value: "provider boom" },
providerExecuted: true,
}),
LLMEvent.stepFinish({ index: 0, reason: "stop" }),
LLMEvent.finish({ reason: "stop" }),
),
}),
)
const providerErrorEnv = SessionProcessor.layer.pipe(
Layer.provide(summary),
Layer.provide(Image.defaultLayer),
Layer.provide(RuntimeFlags.layer({ experimentalEventSystem: true })),
Layer.provide(providerErrorLLM),
Layer.provideMerge(deps),
)
const itProviderError = testEffect(providerErrorEnv)
const fragmentFailureLLM = Layer.succeed(
LLM.Service,
LLM.Service.of({
stream: () =>
Stream.make(
LLMEvent.stepStart({ index: 0 }),
LLMEvent.reasoningStart({ id: "reasoning-1" }),
LLMEvent.reasoningDelta({ id: "reasoning-1", text: "thinking" }),
LLMEvent.textStart({ id: "text-1" }),
LLMEvent.textDelta({ id: "text-1", text: "partial" }),
LLMEvent.providerError({ message: "provider boom" }),
),
}),
)
const fragmentFailureEnv = SessionProcessor.layer.pipe(
Layer.provide(summary),
Layer.provide(Image.defaultLayer),
Layer.provide(RuntimeFlags.layer({ experimentalEventSystem: true })),
Layer.provide(fragmentFailureLLM),
Layer.provideMerge(deps),
)
const itFragmentFailure = testEffect(fragmentFailureEnv)
const boot = Effect.fn("test.boot")(function* () {
const processors = yield* SessionProcessor.Service
const session = yield* Session.Service
@@ -936,3 +990,109 @@ it.live("session.processor effect tests mark interruptions aborted without manua
{ config: (url) => providerCfg(url) },
),
)
itProviderError.live("session.processor effect tests fail provider-executed error results", () =>
provideTmpdirInstance(
(dir) =>
Effect.gen(function* () {
const { processors, session, provider } = yield* boot()
const events = yield* EventV2Bridge.Service
const chat = yield* session.create({})
const parent = yield* user(chat.id, "provider tool error")
const msg = yield* assistant(chat.id, parent.id, path.resolve(dir))
const mdl = yield* provider.getModel(ref.providerID, ref.modelID)
const settlements: Array<typeof SessionEvent.Tool.Failed.Type> = []
const off = yield* events.listen((event) => {
if (event.type === SessionEvent.Tool.Failed.type) settlements.push(event as typeof SessionEvent.Tool.Failed.Type)
return Effect.void
})
const handle = yield* processors.create({ assistantMessage: msg, sessionID: chat.id, model: mdl })
yield* handle.process({
user: {
id: parent.id,
sessionID: chat.id,
role: "user",
time: parent.time,
agent: parent.agent,
model: { providerID: ref.providerID, modelID: ref.modelID },
} satisfies SessionV1.User,
sessionID: chat.id,
model: mdl,
agent: agent(),
system: [],
messages: [{ role: "user", content: "provider tool error" }],
tools: {},
})
yield* off
const parts = yield* MessageV2.parts(msg.id)
const call = parts.find((part): part is SessionV1.ToolPart => part.type === "tool")
expect(call?.state.status).toBe("error")
if (call?.state.status === "error") expect(call.state.error).toBe("provider boom")
expect(settlements).toHaveLength(1)
expect(settlements[0]?.data).toMatchObject({
callID: "call-1",
error: { type: "unknown", message: "provider boom" },
result: { type: "error", value: "provider boom" },
provider: { executed: true },
})
}),
{ config: cfg },
),
)
itFragmentFailure.live("session.processor effect tests flush partial v2 fragments before step failure", () =>
provideTmpdirInstance(
(dir) =>
Effect.gen(function* () {
const { processors, session, provider } = yield* boot()
const events = yield* EventV2Bridge.Service
const chat = yield* session.create({})
const parent = yield* user(chat.id, "provider failure")
const msg = yield* assistant(chat.id, parent.id, path.resolve(dir))
const mdl = yield* provider.getModel(ref.providerID, ref.modelID)
const seen: string[] = []
let text: string | undefined
let reasoning: string | undefined
const off = yield* events.listen((event) => {
seen.push(event.type)
if (event.type === SessionEvent.Text.Ended.type) text = (event.data as typeof SessionEvent.Text.Ended.data.Type).text
if (event.type === SessionEvent.Reasoning.Ended.type)
reasoning = (event.data as typeof SessionEvent.Reasoning.Ended.data.Type).text
return Effect.void
})
const handle = yield* processors.create({ assistantMessage: msg, sessionID: chat.id, model: mdl })
expect(
yield* handle.process({
user: {
id: parent.id,
sessionID: chat.id,
role: "user",
time: parent.time,
agent: parent.agent,
model: { providerID: ref.providerID, modelID: ref.modelID },
} satisfies SessionV1.User,
sessionID: chat.id,
model: mdl,
agent: agent(),
system: [],
messages: [{ role: "user", content: "provider failure" }],
tools: {},
}),
).toBe("stop")
yield* off
const failed = seen.indexOf(SessionEvent.Step.Failed.type)
expect(failed).toBeGreaterThan(-1)
expect(seen.indexOf(SessionEvent.Text.Ended.type)).toBeLessThan(failed)
expect(seen.indexOf(SessionEvent.Reasoning.Ended.type)).toBeLessThan(failed)
expect(text).toBe("partial")
expect(reasoning).toBe("thinking")
}),
{ config: cfg },
),
)