mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-16 13:05:14 +03:00
feat(codemode): suspend and resume runs, with durable tool calls and idempotency keys
This commit is contained in:
@@ -97,6 +97,55 @@ denies it: the host function is never called, and the program catches the failur
|
||||
fails the way the call itself would: a tool call or asynchronous global rejects its promise, and a synchronous global
|
||||
throws.
|
||||
|
||||
### Suspending and resuming a run
|
||||
|
||||
`runtime.start(code, bindings?, { runId? })` starts a run that can be suspended: `run.result` runs it, and
|
||||
`run.suspend` stops it at the next step boundary and saves its state. Both give the same outcome, a `Result` or:
|
||||
|
||||
```ts
|
||||
type Suspended = {
|
||||
ok: "suspended"
|
||||
state: CodeMode.Snapshot // JSON; CodeMode.toBytes / CodeMode.fromBytes convert it
|
||||
pending: Array<{ id; path; args; key; status: "queued" | "starting" | "started" }>
|
||||
}
|
||||
|
||||
const run = runtime.start(source)
|
||||
const fiber = yield* Effect.forkChild(run.result)
|
||||
const suspended = yield* run.suspend
|
||||
// later, in this process or another one built from the same version:
|
||||
const result = yield* runtime.resume(suspended.state, { [key]: { ok: true, value } }).result
|
||||
```
|
||||
|
||||
Suspending waits briefly (`suspend.graceMs`, 50 ms by default) for running tool calls to finish, so their outcomes are
|
||||
saved. A durable tool's work keeps running and is reattached on resume; any other call still running has an unknown
|
||||
outcome: on resume it runs again if its tool declares `retry: "safe"`, and otherwise its promise rejects with an error
|
||||
the program can catch. `resume`'s second argument settles pending calls whose outcome the host already knows, by key.
|
||||
Every call has an idempotency key, `<runId>:<id>`.
|
||||
|
||||
A state resumes only on the same build of this package, with the same extensions; `resume` throws a
|
||||
`CodeMode.SnapshotError` otherwise, or when the state is malformed. A state larger than `suspend.maxBytes` fails the run
|
||||
instead of suspending it. Built-ins are saved by name and only their changes are copied. Functions an extension returned have no data form: after a resume, calling one
|
||||
throws a `TypeError`. `timeoutMs` counts active time across every resume, and `maxToolCalls` counts every call of the run.
|
||||
|
||||
A durable tool runs its work under the call's key and returns a JSON handle:
|
||||
|
||||
```ts
|
||||
const build = Tool.make({
|
||||
description: "Run a build",
|
||||
input: Schema.Struct({ target: Schema.String }),
|
||||
output: Schema.Struct({ ok: Schema.Boolean }),
|
||||
durable: {
|
||||
start: (input, { key }) => jobs.start(key, input), // launch the work, return a handle quickly
|
||||
attach: (handle) => jobs.wait(handle), // its output; interrupting this detaches, never cancels
|
||||
lookup: (key) => jobs.find(key), // a handle for work started before the run was saved, if any
|
||||
cancel: (handle) => jobs.stop(handle), // a run that ends with the call still running cancels it
|
||||
},
|
||||
})
|
||||
```
|
||||
|
||||
Set `CODEMODE_ROUNDTRIP=1` (`bun run test:roundtrip`) to run the tests with every run saved to bytes and restored into a
|
||||
brand-new runtime at every host call and every few steps.
|
||||
|
||||
### `Extension.make`
|
||||
|
||||
Extensions are host functions a program calls directly as globals, such as `fetch`. Unlike tools they are not in the
|
||||
|
||||
@@ -231,7 +231,11 @@ export const make = <
|
||||
bound.add(name)
|
||||
}
|
||||
}
|
||||
if (options.suspend?.graceMs !== undefined) validateLimit("graceMs" as keyof ExecutionLimits, options.suspend.graceMs, 0)
|
||||
for (const [name, value] of Object.entries(options.suspend ?? {})) {
|
||||
if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
|
||||
throw new RangeError(`suspend.${name} must be a safe integer greater than or equal to 0.`)
|
||||
}
|
||||
}
|
||||
const setup: Setup<Environment<Provided, Extensions>> = {
|
||||
prepared,
|
||||
limits,
|
||||
|
||||
@@ -173,10 +173,12 @@ export class Driver<R> {
|
||||
// Starts host work now; its outcome goes back to the machine: a blocking call's continues the job that made it, a
|
||||
// concurrent call's waits in the inbox and settles its promise in a later job, in completion order.
|
||||
private launch(call: HostCall): void {
|
||||
// A call that was running when its run was suspended was admitted then; running it again is not a new call.
|
||||
const again = call.status !== "queued"
|
||||
call.status = "starting"
|
||||
const request = call.request
|
||||
if (request.kind === "tool" && this.tools.tool(request.path)?.durable !== undefined) {
|
||||
return this.fork(call.id, this.tools.start(request.path, request.args, call.key), (handle) => {
|
||||
return this.fork(call.id, this.tools.start(request.path, request.args, call.key, again), (handle) => {
|
||||
const current = this.machine.call(call.id)
|
||||
if (current === undefined) return
|
||||
current.status = "started"
|
||||
@@ -184,8 +186,8 @@ export class Driver<R> {
|
||||
this.attach(current)
|
||||
})
|
||||
}
|
||||
if (request.kind === "tool") return this.fork(call.id, this.tools.execute(request.path, request.args))
|
||||
if (request.kind === "search") return this.fork(call.id, this.tools.search(request.args))
|
||||
if (request.kind === "tool") return this.fork(call.id, this.tools.execute(request.path, request.args, again))
|
||||
if (request.kind === "search") return this.fork(call.id, this.tools.search(request.args, again))
|
||||
// An extension's work, made by the extension bridge with the program's services in its requirements.
|
||||
return this.fork(call.id, this.machine.ctx.extensionWork!(request.call) as Effect.Effect<unknown, unknown, R>)
|
||||
}
|
||||
|
||||
@@ -447,7 +447,7 @@ class Encoder {
|
||||
}
|
||||
if (object instanceof Native) {
|
||||
// A host function made while the program ran: an extension's result. Its name says what was lost.
|
||||
this.lose(`the function ${String(object.props.get("name") && "value" in object.props.get("name")! ? (object.props.get("name") as { value: unknown }).value : "")}`)
|
||||
this.lose(`the function ${functionName(object)}`)
|
||||
return { t: "LostNative", ...this.fields(object, byName.get("Fn")!, ["length"]) }
|
||||
}
|
||||
const proto = Object.getPrototypeOf(object)
|
||||
@@ -733,11 +733,10 @@ class Decoder {
|
||||
case "LostNative": {
|
||||
this.fillClass(target, record, byName.get("Fn")!, false, ["length"])
|
||||
const native = target as unknown as { tag: string; call: unknown; construct: unknown; callback: boolean }
|
||||
const slot = (target as unknown as Obj).props.get("name")
|
||||
const name = slot !== undefined && "value" in slot && typeof slot.value === "string" ? slot.value : ""
|
||||
const name = functionName(target as unknown as Obj)
|
||||
native.tag = "Function"
|
||||
native.call = (_: unknown, __: unknown, site: AstNode | undefined) => {
|
||||
throw lostError(`The function ${name || "(anonymous)"}`, site)
|
||||
throw lostError(`The function ${name}`, site)
|
||||
}
|
||||
native.construct = undefined
|
||||
native.callback = true
|
||||
@@ -873,6 +872,13 @@ class Decoder {
|
||||
}
|
||||
}
|
||||
|
||||
const functionName = (fn: Obj): string => {
|
||||
const slot = fn.props.get("name")
|
||||
return slot !== undefined && "value" in slot && typeof slot.value === "string" && slot.value !== ""
|
||||
? slot.value
|
||||
: "(anonymous)"
|
||||
}
|
||||
|
||||
const base64 = (bytes: Uint8Array): string => {
|
||||
let binary = ""
|
||||
for (let at = 0; at < bytes.length; at += 0x8000) binary += String.fromCharCode(...bytes.subarray(at, at + 0x8000))
|
||||
|
||||
@@ -375,16 +375,23 @@ export class ToolRuntimeError extends Error {
|
||||
export type ToolRuntime<R = never> = {
|
||||
readonly calls: Array<ToolCall>
|
||||
readonly hooks: Hooks<R>
|
||||
/** Runs a tool call. `again` runs one admitted before, re-run on resume: it is not counted a second time. */
|
||||
readonly execute: (
|
||||
path: ReadonlyArray<string>,
|
||||
args: Array<Json | undefined>,
|
||||
again?: boolean,
|
||||
) => Effect.Effect<Json | undefined, unknown, R>
|
||||
readonly search: (args: Array<Json | undefined>) => Effect.Effect<Json | undefined, unknown, R>
|
||||
readonly search: (args: Array<Json | undefined>, again?: boolean) => Effect.Effect<Json | undefined, unknown, R>
|
||||
readonly keys: (path: ReadonlyArray<string>) => ReadonlyArray<string>
|
||||
/** The tool at `path`, if there is one, so a caller can see whether it is durable or safe to retry. */
|
||||
readonly tool: (path: ReadonlyArray<string>) => Tool<R> | undefined
|
||||
/** Admits a call to a durable tool, as `execute` does, and starts its work under `key`: its handle. */
|
||||
readonly start: (path: ReadonlyArray<string>, args: Array<Json | undefined>, key: string) => Effect.Effect<Handle, unknown, R>
|
||||
readonly start: (
|
||||
path: ReadonlyArray<string>,
|
||||
args: Array<Json | undefined>,
|
||||
key: string,
|
||||
again?: boolean,
|
||||
) => Effect.Effect<Handle, unknown, R>
|
||||
/** Waits for a durable tool's work: its output, as `execute` gives it. Interrupting it detaches. */
|
||||
readonly attach: (
|
||||
path: ReadonlyArray<string>,
|
||||
@@ -454,10 +461,10 @@ export const make = <R>(
|
||||
catch: (cause) => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}': ${cause}`),
|
||||
})
|
||||
|
||||
const executeTool = (name: string, tool: Tool<R>, args: Array<Json | undefined>) =>
|
||||
const executeTool = (name: string, tool: Tool<R>, args: Array<Json | undefined>, again = false) =>
|
||||
Effect.gen(function* () {
|
||||
const input = yield* decode(name, tool, args)
|
||||
yield* Effect.sync(() => recordCall({ name }))
|
||||
if (!again) yield* Effect.sync(() => recordCall({ name }))
|
||||
return yield* hooked(
|
||||
{ name, input },
|
||||
hooks["tool.before"],
|
||||
@@ -479,22 +486,23 @@ export const make = <R>(
|
||||
calls,
|
||||
hooks,
|
||||
keys: (path) => namespaceKeys(root, path),
|
||||
search: (args) => Effect.suspend(() => executeTool("search", makeSearchTool(prepared.searchIndex), args)),
|
||||
execute: (path, args) =>
|
||||
search: (args, again) =>
|
||||
Effect.suspend(() => executeTool("search", makeSearchTool(prepared.searchIndex), args, again)),
|
||||
execute: (path, args, again) =>
|
||||
Effect.suspend(() => {
|
||||
const segments = canonicalSegments(path)
|
||||
// Models often write `tools.search(...)` for the bare `search(...)`; honor it unless a tool owns that path.
|
||||
if (segments.length === 1 && segments[0] === "search" && lookup(root, segments) === undefined)
|
||||
return executeTool("search", makeSearchTool(prepared.searchIndex), args)
|
||||
return executeTool(segments.join("."), resolve(root, path, prepared.searchIndex), args)
|
||||
return executeTool("search", makeSearchTool(prepared.searchIndex), args, again)
|
||||
return executeTool(segments.join("."), resolve(root, path, prepared.searchIndex), args, again)
|
||||
}),
|
||||
tool: (path) => lookup(root, canonicalSegments(path))?.tool,
|
||||
start: (path, args, key) =>
|
||||
start: (path, args, key, again) =>
|
||||
Effect.suspend(() => {
|
||||
const found = durableTool(path)
|
||||
return Effect.gen(function* () {
|
||||
const input = yield* decode(found.name, found.tool, args)
|
||||
yield* Effect.sync(() => recordCall({ name: found.name }))
|
||||
if (!again) yield* Effect.sync(() => recordCall({ name: found.name }))
|
||||
const before = hooks["tool.before"]
|
||||
if (before !== undefined) yield* before({ name: found.name, input })
|
||||
return yield* failure(Effect.suspend(() => found.durable.start(input, { key })))
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
// Resumes a saved run in its own process: `bun resume-process.ts <state file> <pending key>`. The `slow` tool answers
|
||||
// `{ value: input.value * 2 }`; the pending call's outcome is given as `{ value: 20 }`.
|
||||
import { Effect, Schema } from "effect"
|
||||
import { CodeMode, Tool } from "../../src/index.js"
|
||||
|
||||
const Value = Schema.Struct({ value: Schema.Number })
|
||||
const slow = Tool.make({
|
||||
description: "Doubles",
|
||||
input: Value,
|
||||
output: Value,
|
||||
execute: (input) => Effect.succeed({ value: input.value * 2 }),
|
||||
})
|
||||
const [file, key] = process.argv.slice(2)
|
||||
const bytes = new Uint8Array(await Bun.file(file!).arrayBuffer())
|
||||
const run = CodeMode.make({ tools: { slow } }).resume(bytes, { [key!]: { ok: true, value: { value: 20 } } })
|
||||
console.log(JSON.stringify(await Effect.runPromise(run.result)))
|
||||
@@ -0,0 +1,488 @@
|
||||
import { describe, expect, test } from "bun:test"
|
||||
import { tmpdir } from "node:os"
|
||||
import path from "node:path"
|
||||
import { Effect, Fiber, Schema } from "effect"
|
||||
import { CodeMode, Extension, Tool } from "../src/index.js"
|
||||
|
||||
// Suspending a run, saving its state, and resuming it in a brand-new runtime.
|
||||
|
||||
const Value = Schema.Struct({ value: Schema.Number })
|
||||
|
||||
/** A promise and its resolver, for host work a test finishes by hand. */
|
||||
const latch = <A = void>() => {
|
||||
let resolve!: (value: A) => void
|
||||
const promise = new Promise<A>((done) => (resolve = done))
|
||||
return { promise, resolve }
|
||||
}
|
||||
|
||||
/** A tool that announces each call and waits for the test to answer it. */
|
||||
const manual = (options: { retry?: "safe" | "unsafe" } = {}) => {
|
||||
const calls: Array<{ input: number; answer: (value: number) => void }> = []
|
||||
let called = latch()
|
||||
const tool = Tool.make({
|
||||
description: "Waits for the test",
|
||||
input: Value,
|
||||
output: Value,
|
||||
...options,
|
||||
execute: (input) =>
|
||||
Effect.promise(() => {
|
||||
const answer = latch<number>()
|
||||
calls.push({ input: input.value, answer: answer.resolve })
|
||||
called.resolve()
|
||||
return answer.promise.then((value) => ({ value }))
|
||||
}),
|
||||
})
|
||||
return {
|
||||
tool,
|
||||
calls,
|
||||
called: () => called.promise,
|
||||
reset: () => {
|
||||
called = latch()
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/** A durable tool over an in-memory job table that outlives any one run, as a process supervisor would. */
|
||||
const durableJobs = (options: { startHangs?: boolean } = {}) => {
|
||||
const jobs = new Map<string, { input: number; result: ReturnType<typeof latch<number>>; cancelled: boolean }>()
|
||||
const log: Array<string> = []
|
||||
let started = latch()
|
||||
const tool = Tool.make({
|
||||
description: "Runs a job",
|
||||
input: Value,
|
||||
output: Value,
|
||||
durable: {
|
||||
start: (input, { key }) =>
|
||||
Effect.gen(function* () {
|
||||
log.push(`start ${key}`)
|
||||
jobs.set(key, { input: input.value, result: latch<number>(), cancelled: false })
|
||||
started.resolve()
|
||||
if (options.startHangs) yield* Effect.never
|
||||
return { job: key }
|
||||
}),
|
||||
attach: (handle) =>
|
||||
Effect.promise(() => {
|
||||
const key = (handle as { job: string }).job
|
||||
log.push(`attach ${key}`)
|
||||
return jobs.get(key)!.result.promise.then((value) => ({ value }))
|
||||
}),
|
||||
lookup: (key) =>
|
||||
Effect.sync(() => {
|
||||
log.push(`lookup ${key}`)
|
||||
return jobs.has(key) ? { job: key } : undefined
|
||||
}),
|
||||
cancel: (handle) =>
|
||||
Effect.sync(() => {
|
||||
const key = (handle as { job: string }).job
|
||||
log.push(`cancel ${key}`)
|
||||
jobs.get(key)!.cancelled = true
|
||||
}),
|
||||
},
|
||||
})
|
||||
return {
|
||||
tool,
|
||||
jobs,
|
||||
log,
|
||||
started: () => started.promise,
|
||||
finish: (key: string, value: number) => jobs.get(key)!.result.resolve(value),
|
||||
reset: () => {
|
||||
started = latch()
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
const suspendedOf = (outcome: CodeMode.Result | CodeMode.Suspended): CodeMode.Suspended => {
|
||||
if (outcome.ok !== "suspended") throw new Error(`expected a suspended run, got ${JSON.stringify(outcome)}`)
|
||||
return outcome
|
||||
}
|
||||
|
||||
describe("suspend and resume", () => {
|
||||
test("a run suspended at a tool call resumes in a fresh runtime, from the state or its bytes", async () => {
|
||||
const first = manual()
|
||||
const code = `
|
||||
const log = []
|
||||
log.push("before")
|
||||
const a = await tools.slow({ value: 1 })
|
||||
log.push("after " + a.value)
|
||||
console.log("resumed")
|
||||
return { log, total: a.value + 1 }`
|
||||
const run = CodeMode.make({ tools: { slow: first.tool } }).start(code, undefined, { runId: "run-1" })
|
||||
const fiber = Effect.runFork(run.result)
|
||||
await first.called()
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
// The run's own result is the same saved state.
|
||||
expect(suspendedOf(await Effect.runPromise(Fiber.join(fiber)))).toBe(suspended)
|
||||
expect(suspended.pending).toEqual([{ id: 0, path: "slow", args: [{ value: 1 }], key: "run-1:0", status: "starting" }])
|
||||
|
||||
const bytes = CodeMode.toBytes(suspended.state)
|
||||
for (const state of [suspended.state, bytes] as const) {
|
||||
const outcome = await Effect.runPromise(
|
||||
CodeMode.make({ tools: { slow: first.tool } }).resume(state, { "run-1:0": { ok: true, value: { value: 41 } } })
|
||||
.result,
|
||||
)
|
||||
expect(outcome).toEqual({
|
||||
ok: true,
|
||||
value: { log: ["before", "after 41"], total: 42 },
|
||||
logs: ["resumed"],
|
||||
toolCalls: [{ name: "slow" }],
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
test("a run saved to a file resumes in another process", async () => {
|
||||
const first = manual()
|
||||
const run = CodeMode.make({ tools: { slow: first.tool } }).start(`
|
||||
const seen = new Map([["first", await tools.slow({ value: 10 })]])
|
||||
const second = await tools.slow({ value: 21 })
|
||||
return [seen.get("first").value, second.value]`)
|
||||
Effect.runFork(run.result)
|
||||
await first.called()
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
const file = path.join(tmpdir(), `codemode-${crypto.randomUUID()}.state`)
|
||||
await Bun.write(file, CodeMode.toBytes(suspended.state))
|
||||
try {
|
||||
const child = Bun.spawn(["bun", path.join(import.meta.dir, "fixtures/resume-process.ts"), file, suspended.pending[0]!.key], {
|
||||
stdout: "pipe",
|
||||
stderr: "inherit",
|
||||
})
|
||||
const output = await new Response(child.stdout).text()
|
||||
expect(await child.exited).toBe(0)
|
||||
expect(JSON.parse(output)).toEqual({ ok: true, value: [20, 42], toolCalls: [{ name: "slow" }, { name: "slow" }] })
|
||||
} finally {
|
||||
await Bun.file(file).delete()
|
||||
}
|
||||
})
|
||||
|
||||
test("a suspend before the run starts saves its initial state", async () => {
|
||||
const runtime = CodeMode.make({ tools: {} })
|
||||
const run = runtime.start(`let n = 0; for (let i = 0; i < 10; i++) n += i; return n`)
|
||||
const suspended = suspendedOf(await Effect.runPromise(Effect.andThen(Effect.forkChild(run.result), run.suspend)))
|
||||
expect(suspended.pending).toEqual([])
|
||||
expect(await Effect.runPromise(runtime.resume(suspended.state).result)).toEqual({
|
||||
ok: true,
|
||||
value: 45,
|
||||
toolCalls: [],
|
||||
})
|
||||
})
|
||||
|
||||
test("a suspended durable tool's work keeps running and is reattached by its handle", async () => {
|
||||
const jobs = durableJobs()
|
||||
const runtime = CodeMode.make({ tools: { job: jobs.tool } })
|
||||
const run = runtime.start(`const r = await tools.job({ value: 2 }); return r.value * 10`, undefined, {
|
||||
runId: "d",
|
||||
})
|
||||
Effect.runFork(run.result)
|
||||
await jobs.started()
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
expect(suspended.pending).toEqual([{ id: 0, path: "job", args: [{ value: 2 }], key: "d:0", status: "started" }])
|
||||
// Detached, not cancelled: the work finishes while nothing waits on it.
|
||||
expect(jobs.jobs.get("d:0")!.cancelled).toBe(false)
|
||||
jobs.finish("d:0", 7)
|
||||
const outcome = await Effect.runPromise(
|
||||
CodeMode.make({ tools: { job: jobs.tool } }).resume(CodeMode.toBytes(suspended.state)).result,
|
||||
)
|
||||
expect(outcome).toEqual({ ok: true, value: 70, toolCalls: [{ name: "job" }] })
|
||||
expect(jobs.log).toEqual(["start d:0", "attach d:0", "attach d:0"])
|
||||
})
|
||||
|
||||
test("a durable call saved before its start returned is found by key, or started again", async () => {
|
||||
for (const found of [true, false]) {
|
||||
const jobs = durableJobs({ startHangs: true })
|
||||
const run = CodeMode.make({ tools: { job: jobs.tool }, suspend: { graceMs: 0 } }).start(
|
||||
`return (await tools.job({ value: 3 })).value`,
|
||||
undefined,
|
||||
{ runId: "c" },
|
||||
)
|
||||
Effect.runFork(run.result)
|
||||
await jobs.started()
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
expect(suspended.pending.map((call) => call.status)).toEqual(["starting"])
|
||||
// As if the host crashed after start launched the work but before the run was saved again.
|
||||
if (!found) jobs.jobs.clear()
|
||||
const fresh = durableJobs()
|
||||
fresh.jobs.set("c:0", jobs.jobs.get("c:0") ?? { input: 3, result: latch<number>(), cancelled: false })
|
||||
if (!found) fresh.jobs.clear()
|
||||
const resumed = CodeMode.make({ tools: { job: fresh.tool } }).resume(suspended.state)
|
||||
const result = Effect.runPromise(resumed.result)
|
||||
if (!found) await fresh.started()
|
||||
fresh.finish("c:0", found ? 5 : 6)
|
||||
expect(await result).toEqual({ ok: true, value: found ? 5 : 6, toolCalls: [{ name: "job" }] })
|
||||
expect(fresh.log).toEqual(found ? ["lookup c:0", "attach c:0"] : ["lookup c:0", "start c:0", "attach c:0"])
|
||||
}
|
||||
})
|
||||
|
||||
test("a call in flight when suspended re-runs when safe to retry, and otherwise rejects catchably", async () => {
|
||||
const code = `
|
||||
try {
|
||||
return { value: (await tools.work({ value: 4 })).value }
|
||||
} catch (error) {
|
||||
return { caught: String(error) }
|
||||
}`
|
||||
for (const retry of ["safe", "unsafe"] as const) {
|
||||
const first = manual({ retry })
|
||||
const run = CodeMode.make({ tools: { work: first.tool }, suspend: { graceMs: 0 } }).start(code, undefined, {
|
||||
runId: "r",
|
||||
})
|
||||
Effect.runFork(run.result)
|
||||
await first.called()
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
expect(suspended.pending.map((call) => [call.key, call.status])).toEqual([["r:0", "starting"]])
|
||||
const second = manual({ retry })
|
||||
const result = Effect.runPromise(CodeMode.make({ tools: { work: second.tool } }).resume(suspended.state).result)
|
||||
if (retry === "safe") {
|
||||
await second.called()
|
||||
expect(second.calls[0]!.input).toBe(4)
|
||||
second.calls[0]!.answer(9)
|
||||
expect(await result).toEqual({ ok: true, value: { value: 9 }, toolCalls: [{ name: "work" }] })
|
||||
continue
|
||||
}
|
||||
expect(second.calls).toEqual([])
|
||||
expect(await result).toEqual({
|
||||
ok: true,
|
||||
value: {
|
||||
caught:
|
||||
"Error: The call to work was interrupted when the run was suspended and may have partially run; check its effects before calling it again.",
|
||||
},
|
||||
toolCalls: [{ name: "work" }],
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
test("calls of every kind settle at a suspend inside Promise.all", async () => {
|
||||
const quick = Tool.make({
|
||||
description: "Answers at once",
|
||||
input: Value,
|
||||
output: Value,
|
||||
execute: (input) => Effect.succeed({ value: input.value * 100 }),
|
||||
})
|
||||
const slow = manual()
|
||||
const safe = manual({ retry: "safe" })
|
||||
const jobs = durableJobs()
|
||||
const tools = { quick, slow: slow.tool, safe: safe.tool, job: jobs.tool }
|
||||
const code = `
|
||||
const settled = await Promise.allSettled([
|
||||
tools.quick({ value: 1 }),
|
||||
tools.slow({ value: 2 }),
|
||||
tools.safe({ value: 3 }),
|
||||
tools.job({ value: 4 }),
|
||||
])
|
||||
return settled.map((item) => item.status === "fulfilled" ? item.value.value : String(item.reason))`
|
||||
const run = CodeMode.make({ tools, suspend: { graceMs: 20 } }).start(code, undefined, { runId: "m" })
|
||||
Effect.runFork(run.result)
|
||||
await Promise.all([slow.called(), safe.called(), jobs.started()])
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
// The quick call finished within the grace period, so its outcome is part of the state.
|
||||
expect(suspended.pending.map((call) => [call.path, call.status])).toEqual([
|
||||
["slow", "starting"],
|
||||
["safe", "starting"],
|
||||
["job", "started"],
|
||||
])
|
||||
safe.reset()
|
||||
const result = Effect.runPromise(CodeMode.make({ tools }).resume(CodeMode.toBytes(suspended.state)).result)
|
||||
await safe.called()
|
||||
safe.calls[1]!.answer(30)
|
||||
jobs.finish("m:3", 40)
|
||||
expect(await result).toMatchObject({
|
||||
ok: true,
|
||||
value: [
|
||||
100,
|
||||
"Error: The call to slow was interrupted when the run was suspended and may have partially run; check its effects before calling it again.",
|
||||
30,
|
||||
40,
|
||||
],
|
||||
})
|
||||
})
|
||||
|
||||
test("active time and tool calls count across resumes", async () => {
|
||||
const first = manual()
|
||||
const runtime = CodeMode.make({ tools: { slow: first.tool }, limits: { timeoutMs: 400, maxToolCalls: 1 } })
|
||||
const run = runtime.start(`
|
||||
let n = 0
|
||||
const started = Date.now()
|
||||
while (Date.now() - started < 150) n++
|
||||
await tools.slow({ value: 1 })
|
||||
await tools.slow({ value: 2 })
|
||||
return n`)
|
||||
Effect.runFork(run.result)
|
||||
await first.called()
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
expect(suspended.state.header.budget.activeMs).toBeGreaterThanOrEqual(150)
|
||||
expect(suspended.state.header.budget.toolCalls).toBe(1)
|
||||
// The second call is over the limit the first one used up before the suspend.
|
||||
const resumed = await Effect.runPromise(
|
||||
runtime.resume(suspended.state, { [suspended.pending[0]!.key]: { ok: true, value: { value: 1 } } }).result,
|
||||
)
|
||||
expect(resumed).toMatchObject({ ok: false, error: { kind: "ToolCallLimitExceeded" } })
|
||||
|
||||
const busy = CodeMode.make({ tools: { slow: first.tool }, limits: { timeoutMs: 300 } })
|
||||
first.reset()
|
||||
const spin = busy.start(`
|
||||
const started = Date.now()
|
||||
while (Date.now() - started < 200) {}
|
||||
await tools.slow({ value: 1 })
|
||||
const again = Date.now()
|
||||
while (Date.now() - again < 200) {}
|
||||
return "done"`)
|
||||
Effect.runFork(spin.result)
|
||||
await first.called()
|
||||
const paused = suspendedOf(await Effect.runPromise(spin.suspend))
|
||||
// 200ms were used before the suspend; the next 200ms of work go past the 300ms limit.
|
||||
const timedOut = await Effect.runPromise(
|
||||
busy.resume(paused.state, { [paused.pending[0]!.key]: { ok: true, value: { value: 1 } } }).result,
|
||||
)
|
||||
expect(timedOut).toMatchObject({ ok: false, error: { kind: "TimeoutExceeded" } })
|
||||
})
|
||||
|
||||
test("a function an extension returned is lost on resume, and calling it fails clearly", async () => {
|
||||
const extension = Extension.make({ name: "maker", globals: { make: () => function inc(x: number) { return x + 1 } } })
|
||||
const first = manual()
|
||||
const runtime = CodeMode.make({ tools: { slow: first.tool }, extensions: [extension] })
|
||||
const run = runtime.start(`
|
||||
const inc = make()
|
||||
const before = inc(1)
|
||||
await tools.slow({ value: 0 })
|
||||
try {
|
||||
return { before, after: inc(1) }
|
||||
} catch (error) {
|
||||
return { before, error: String(error) }
|
||||
}`)
|
||||
Effect.runFork(run.result)
|
||||
await first.called()
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
const outcome = await Effect.runPromise(
|
||||
CodeMode.make({ tools: { slow: first.tool }, extensions: [extension] }).resume(suspended.state, {
|
||||
[suspended.pending[0]!.key]: { ok: true, value: { value: 0 } },
|
||||
}).result,
|
||||
)
|
||||
expect(outcome).toMatchObject({
|
||||
ok: true,
|
||||
value: {
|
||||
before: 2,
|
||||
error:
|
||||
"TypeError: The function inc came from the host and was lost when the run was suspended; get it again after resuming.",
|
||||
},
|
||||
})
|
||||
})
|
||||
|
||||
test("a durable call the program leaves running is cancelled when it ends", async () => {
|
||||
const jobs = durableJobs()
|
||||
const outcome = await Effect.runPromise(
|
||||
CodeMode.make({ tools: { job: jobs.tool } })
|
||||
.start(`tools.job({ value: 1 }); return "left"`, undefined, { runId: "e" })
|
||||
.result,
|
||||
)
|
||||
expect(outcome).toMatchObject({ ok: true, value: "left" })
|
||||
expect(jobs.jobs.get("e:0")!.cancelled).toBe(true)
|
||||
})
|
||||
|
||||
test("the snapshot codec does not import Effect", async () => {
|
||||
for (const file of ["codec.ts", "snapshot.ts"]) {
|
||||
expect(await Bun.file(`${import.meta.dir}/../src/snapshot/${file}`).text()).not.toMatch(/from "effect"/)
|
||||
}
|
||||
})
|
||||
|
||||
test("a state is refused by another build, other extensions, or a changed source", async () => {
|
||||
const first = manual()
|
||||
const runtime = CodeMode.make({ tools: { slow: first.tool } })
|
||||
const run = runtime.start(`await tools.slow({ value: 1 }); return 1`)
|
||||
Effect.runFork(run.result)
|
||||
await first.called()
|
||||
const state = suspendedOf(await Effect.runPromise(run.suspend)).state
|
||||
const header = state.header
|
||||
expect(() => runtime.resume({ ...state, header: { ...header, build: "0.0.0+0" } })).toThrow(
|
||||
/saved by another Code Mode build \(0\.0\.0\+0\)/,
|
||||
)
|
||||
const other = CodeMode.make({ extensions: [Extension.make({ name: "x", globals: { f: () => 1 } })] })
|
||||
expect(() => other.resume(state)).toThrow("saved by a runtime with other host globals")
|
||||
const source = header.sources[0]!
|
||||
expect(() =>
|
||||
runtime.resume({ ...state, header: { ...header, sources: [{ ...source, code: `${source.code} ` }] } }),
|
||||
).toThrow("Source main does not match its hash.")
|
||||
expect(() => runtime.resume(new TextEncoder().encode("{"))).toThrow(CodeMode.SnapshotError)
|
||||
expect(() => runtime.resume({ ...state, records: [{ t: "Nope" }] })).toThrow("Invalid snapshot")
|
||||
})
|
||||
|
||||
test("a state over the byte budget fails the run instead of suspending it", async () => {
|
||||
const first = manual()
|
||||
const run = CodeMode.make({ tools: { slow: first.tool }, suspend: { maxBytes: 100 } }).start(
|
||||
`const big = "x".repeat(1000); await tools.slow({ value: 1 }); return big.length`,
|
||||
)
|
||||
Effect.runFork(run.result)
|
||||
await first.called()
|
||||
expect(await Effect.runPromise(run.suspend)).toMatchObject({
|
||||
ok: false,
|
||||
error: { kind: "ExecutionFailure", message: expect.stringContaining("more than the 100-byte limit") },
|
||||
})
|
||||
})
|
||||
|
||||
test("program state of every kind survives a suspend", async () => {
|
||||
const first = manual()
|
||||
const code = `
|
||||
const shared = { n: 1 }
|
||||
const map = new Map([[shared, "a"], ["k", shared]])
|
||||
const set = new Set([1, shared])
|
||||
const it = map.keys()
|
||||
it.next()
|
||||
const url = new URL("https://example.com/a?x=1")
|
||||
const params = url.searchParams
|
||||
const bytes = new Uint8Array([1, 2, 3, 4])
|
||||
const view = bytes.subarray(1, 3)
|
||||
const re = /a(b)/g
|
||||
re.test("abab")
|
||||
const date = new Date(0)
|
||||
const weak = new WeakMap([[shared, 5]])
|
||||
function* counter() { let i = 0; while (true) yield i++ }
|
||||
const gen = counter()
|
||||
gen.next()
|
||||
const bound = ((a, b) => a + b).bind(null, 10)
|
||||
const sparse = []
|
||||
sparse[5000] = "far"
|
||||
const pending = new Promise((resolve) => (globalResolve = resolve))
|
||||
var globalResolve
|
||||
Array.prototype.extra = "patched"
|
||||
await tools.slow({ value: 1 })
|
||||
params.append("y", "2")
|
||||
view[0] = 9
|
||||
globalResolve("later")
|
||||
return {
|
||||
same: map.get("k") === shared && set.has(shared) && weak.get(shared) === 5,
|
||||
next: it.next().value,
|
||||
url: url.href,
|
||||
bytes: [...bytes],
|
||||
lastIndex: re.lastIndex,
|
||||
date: date.getTime(),
|
||||
gen: [gen.next().value, gen.next().value],
|
||||
bound: bound(5),
|
||||
sparse: [sparse.length, sparse[5000], 4999 in sparse],
|
||||
pending: await pending,
|
||||
extra: [].extra,
|
||||
negative: Object.is(-0, -0 * 1),
|
||||
}`
|
||||
const run = CodeMode.make({ tools: { slow: first.tool } }).start(code)
|
||||
Effect.runFork(run.result)
|
||||
await first.called()
|
||||
const suspended = suspendedOf(await Effect.runPromise(run.suspend))
|
||||
const outcome = await Effect.runPromise(
|
||||
CodeMode.make({ tools: { slow: first.tool } }).resume(CodeMode.toBytes(suspended.state), {
|
||||
[suspended.pending[0]!.key]: { ok: true, value: { value: 1 } },
|
||||
}).result,
|
||||
)
|
||||
expect(outcome).toMatchObject({
|
||||
ok: true,
|
||||
value: {
|
||||
same: true,
|
||||
next: "k",
|
||||
url: "https://example.com/a?x=1&y=2",
|
||||
bytes: [1, 9, 3, 4],
|
||||
lastIndex: 2,
|
||||
date: 0,
|
||||
gen: [1, 2],
|
||||
bound: 15,
|
||||
sparse: [5001, "far", false],
|
||||
pending: "later",
|
||||
extra: "patched",
|
||||
negative: true,
|
||||
},
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user