317
const resumed = (
318
entries: ReadonlyArray<ProviderReplayEntry>,
319
options?: {
320
- readonly version?: "2.2.5";
320
+ readonly version?: "2.2.5" | "2.2.6";
321
readonly goal?: OrchestrationV2ProviderThread["goal"];
322
readonly external?: boolean;
323
readonly supervised?: boolean;
326
readonly resolveExtractedTextPath?: (path: string) => Effect.Effect<string | undefined>;
327
readonly fileSystem?: FileSystem.FileSystem;
328
readonly onPrompt?: (input: unknown) => void;
329
+ readonly borrowers?: { current: number };
330
},
331
) =>
332
Effect.gen(function* () {
336
out("session.get", { sessionID: SESSION }),
337
replyData("session.get", sessionInfo()),
338
...noOpenRequests,
338
- ...(options?.version === "2.2.5"
339
+ ...(options?.version !== undefined
340
? [out("rpc.call", "<any>"), reply("rpc.call", { output: null })]
341
: []),
342
...withInstructions([
353
],
354
{
355
...(options?.version === undefined ? {} : { version: options.version }),
356
+ ...(options?.borrowers === undefined ? {} : { borrowers: options.borrowers }),
357
...(options?.fileSystem === undefined ? {} : { fileSystem: options.fileSystem }),
358
...(options?.onPrompt === undefined ? {} : { onPrompt: options.onPrompt }),
359
...(options?.external === undefined ? {} : { external: options.external }),
2893
}).pipe(Effect.scoped),
2894
);
2895
2896
+ it.effect.each(["completed", "error", "cancelled"] as const)(
2897
+ "retains native image job %s after its launch returns",
2898
+ (outcome) =>
2899
+ Effect.gen(function* () {
2900
+ const tool = { sessionID: SESSION, assistantMessageID: "msg_assistant", id: "call-image" };
2901
+ const notice = (sessionID: string) =>
2902
+ event("session.inbox.enqueued", {
2903
+ sessionID,
2904
+ inboxID: `msg_image_${sessionID}`,
2905
+ item: {
2906
+ type: "synthetic",
2907
+ delivery: "steer",
2908
+ payload: {
2909
+ description: "Image generation",
2910
+ text:
2911
+ outcome === "completed"
2912
+ ? "Image outcome retained. Saved image: /work/opencode2/image.png (test/image)."
2913
+ : "Image outcome retained",
2914
+ metadata: {
2915
+ source: "experimental_image_generate",
2916
+ jobID: "image_test",
2917
+ state: outcome,
2918
+ path: "/work/opencode2/image",
2919
+ },
2920
+ },
2921
+ },
2922
+ });
2923
+ const { runtime, thread } = yield* resumed(
2924
+ [
2925
+ out("session.prompt", { sessionID: SESSION, text: "<any>" }),
2926
+ promptAccepted,
2927
+ event("session.tool.input.started", { ...tool, name: "experimental_image_generate" }),
2928
+ event("session.tool.called", { ...tool, input: { prompt: "A tree" }, executed: false }),
2929
+ event(
2930
+ "session.tool.success",
2931
+ {
2932
+ ...tool,
2933
+ content: [{ type: "text", text: "Job launched" }],
2934
+ metadata: {
2935
+ jobID: "image_test",
2936
+ path: "/work/opencode2/image",
2937
+ model: "test/image",
2938
+ },
2939
+ executed: false,
2940
+ },
2941
+ undefined,
2942
+ 2,
2943
+ ),
2944
+ event("session.execution.succeeded", { sessionID: SESSION }),
2945
+ notice("ses_other"),
2946
+ notice(SESSION),
2947
+ ...(outcome === "completed"
2948
+ ? [
2949
+ out("image.read", {
2950
+ path: "/api/fs/read/image.png",
2951
+ "location[directory]": WORK,
2952
+ }),
2953
+ reply("image.read", { imageBase64: "iVBORw0KGgo=" }),
2954
+ ]
2955
+ : []),
2956
+ ],
2957
+ { external: true },
2958
+ );
2959
+ let launched = false;
2960
+ const events = yield* runtime.events.pipe(
2961
+ Stream.takeUntil((e) => {
2962
+ if (e.type !== "provider_thread.updated") return false;
2963
+ if (
2964
+ e.providerThread.pendingBackgroundTasks?.some((task) => task.taskId === "image_test")
2965
+ )
2966
+ launched = true;
2967
+ return launched && e.pendingBackgroundWork === false;
2968
+ }),
2969
+ Stream.runCollect,
2970
+ Effect.forkScoped,
2971
+ );
2972
+ yield* runtime.startTurn(turnInput(thread));
2973
+ const collected = yield* Fiber.join(events);
2974
+ const items = collected.flatMap((e) =>
2975
+ e.type === "turn_item.updated" && e.turnItem.nativeItemRef?.nativeId === "call-image"
2976
+ ? [e.turnItem]
2977
+ : [],
2978
+ );
2979
+ assert.deepEqual(
2980
+ items.map((item) => item.status),
2981
+ [
2982
+ "running",
2983
+ "running",
2984
+ "running",
2985
+ outcome === "error" ? "failed" : outcome === "cancelled" ? "interrupted" : "completed",
2986
+ ],
2987
+ );
2988
+ assert.include(JSON.stringify(items.at(-1)), "Image outcome retained");
2989
+ if (outcome === "completed") {
2990
+ const item = items.at(-1);
2991
+ assert.deepEqual(item?.type === "dynamic_tool" ? toolOutputImages(item.output) : [], [
2992
+ { mimeType: "image/png", data: "iVBORw0KGgo=" },
2993
+ ]);
2994
+ }
2995
+ const rosters = collected.flatMap((e) =>
2996
+ e.type === "provider_thread.updated"
2997
+ ? [e.providerThread.pendingBackgroundTasks ?? []]
2998
+ : [],
2999
+ );
3000
+ assert.isTrue(rosters.some((tasks) => tasks.some((task) => task.taskId === "image_test")));
3001
+ assert.deepEqual(rosters.at(-1), []);
3002
+ }).pipe(Effect.scoped),
3003
+ );
3004
+
3005
+ it.effect.each(["history", "list", "late-preview"] as const)(
3006
+ "recovers native image job outcomes from %s after reconnect",
3007
+ (source) =>
3008
+ Effect.gen(function* () {
3009
+ const { runtime, thread } = yield* resumed(
3010
+ [
3011
+ out("session.prompt", { sessionID: SESSION, id: PROMPT_ID, text: "<any>" }),
3012
+ promptAccepted,
3013
+ ...(() => {
3014
+ const frames: Array<ProviderReplayEntry> = reconnected({}, "succeeded", {
3015
+ content: [
3016
+ {
3017
+ type: "tool",
3018
+ id: "call-image-gap",
3019
+ name: "experimental_image_generate",
3020
+ executed: false,
3021
+ state: {
3022
+ status: "completed",
3023
+ input: { prompt: "A tree" },
3024
+ content: [{ type: "text", text: "Job launched" }],
3025
+ metadata: { jobID: "image_gap", path: "/tmp/image", model: "test/image" },
3026
+ },
3027
+ time: { created: 2, ran: 2, completed: 2 },
3028
+ },
3029
+ ],
3030
+ });
3031
+ if (source !== "history")
3032
+ frames.splice(2, 0, out("rpc.call", "<any>"), reply("rpc.call", { output: null }));
3033
+ return frames;
3034
+ })(),
3035
+ out("message.list", { sessionID: SESSION, type: "synthetic", limit: "100" }),
3036
+ reply("message.list", {
3037
+ data:
3038
+ source !== "history"
3039
+ ? []
3040
+ : [
3041
+ {
3042
+ id: "msg_image_gap",
3043
+ time: { created: 3 },
3044
+ type: "synthetic",
3045
+ text: "Recovered image failure",
3046
+ description: "Image generation",
3047
+ metadata: {
3048
+ source: "experimental_image_generate",
3049
+ jobID: "image_gap",
3050
+ state: "error",
3051
+ path: "/tmp/image",
3052
+ },
3053
+ },
3054
+ ],
3055
+ cursor: {},
3056
+ }),
3057
+ ...(source !== "history"
3058
+ ? [
3059
+ out("imageJobs", { sessionID: SESSION, kind: "image" }),
3060
+ reply("imageJobs", {
3061
+ data: [
3062
+ {
3063
+ kind: "image",
3064
+ id: "image_gap",
3065
+ sessionID: SESSION,
3066
+ status: source === "late-preview" ? "completed" : "error",
3067
+ path: "/tmp/image",
3068
+ model: "test/image",
3069
+ time: { started: 2, completed: 3 },
3070
+ },
3071
+ ],
3072
+ }),
3073
+ ]
3074
+ : []),
3075
+ ...(source === "late-preview"
3076
+ ? [
3077
+ event("session.inbox.enqueued", {
3078
+ sessionID: SESSION,
3079
+ inboxID: "msg_image_late",
3080
+ item: {
3081
+ type: "synthetic",
3082
+ delivery: "steer",
3083
+ payload: {
3084
+ description: "Image generation",
3085
+ text: "Image request finished. Saved image: /tmp/image.png (test/image).",
3086
+ metadata: {
3087
+ source: "experimental_image_generate",
3088
+ jobID: "image_gap",
3089
+ state: "completed",
3090
+ path: "/tmp/image",
3091
+ },
3092
+ },
3093
+ },
3094
+ }),
3095
+ out("image.read", {
3096
+ path: "/api/fs/read/image.png",
3097
+ "location[directory]": "/tmp",
3098
+ }),
3099
+ reply("image.read", { imageBase64: "iVBORw0KGgo=" }),
3100
+ ]
3101
+ : []),
3102
+ ],
3103
+ { ...(source !== "history" ? { version: "2.2.6" as const } : {}), external: true },
3104
+ );
3105
+ const events = yield* runtime.events.pipe(
3106
+ Stream.takeUntil(
3107
+ (e) =>
3108
+ e.type === "turn_item.updated" &&
3109
+ e.turnItem.nativeItemRef?.nativeId === "call-image-gap" &&
3110
+ (source === "late-preview"
3111
+ ? e.turnItem.type === "dynamic_tool" &&
3112
+ toolOutputImages(e.turnItem.output).length > 0
3113
+ : e.turnItem.status === "failed"),
3114
+ ),
3115
+ Stream.runCollect,
3116
+ Effect.forkScoped,
3117
+ );
3118
+ yield* runtime.startTurn(turnInput(thread));
3119
+ const collected = yield* Fiber.join(events);
3120
+ assert.include(
3121
+ JSON.stringify(collected.at(-1)),
3122
+ source === "late-preview"
3123
+ ? "Saved image: /tmp/image.png"
3124
+ : source !== "history"
3125
+ ? "Image generation error"
3126
+ : "Recovered image failure",
3127
+ );
3128
+ assert.isTrue(
3129
+ collected.some(
3130
+ (e) =>
3131
+ e.type === "provider_thread.updated" &&
3132
+ e.providerThread.pendingBackgroundTasks?.some((task) => task.taskId === "image_gap"),
3133
+ ),
3134
+ );
3135
+ }).pipe(Effect.scoped),
3136
+ );
3137
+
3138
+ it.effect("settles a recovered image outcome when preview I/O is interrupted", () =>
3139
+ Effect.gen(function* () {
3140
+ const reading = yield* Deferred.make<void>();
3141
+ const interrupted = yield* Deferred.make<void>();
3142
+ const fs = yield* FileSystem.FileSystem;
3143
+ const { runtime, thread } = yield* resumed(
3144
+ [
3145
+ out("session.prompt", { sessionID: SESSION, id: PROMPT_ID, text: "<any>" }),
3146
+ promptAccepted,
3147
+ ...reconnected({}, "succeeded", {
3148
+ content: [
3149
+ {
3150
+ type: "tool",
3151
+ id: "call-image-slow",
3152
+ name: "experimental_image_generate",
3153
+ executed: false,
3154
+ state: {
3155
+ status: "completed",
3156
+ input: { prompt: "A tree" },
3157
+ content: [{ type: "text", text: "Launched" }],
3158
+ metadata: { jobID: "image_slow", path: "/tmp/image", model: "test/image" },
3159
+ },
3160
+ time: { created: 2, ran: 2, completed: 2 },
3161
+ },
3162
+ ],
3163
+ }),
3164
+ out("message.list", { sessionID: SESSION, type: "synthetic", limit: "100" }),
3165
+ reply("message.list", {
3166
+ data: [
3167
+ {
3168
+ id: "msg_image_slow",
3169
+ type: "synthetic",
3170
+ time: { created: 3 },
3171
+ text: "Image request finished. Saved image: /tmp/image.png (test/image).",
3172
+ description: "Image generation",
3173
+ metadata: {
3174
+ source: "experimental_image_generate",
3175
+ jobID: "image_slow",
3176
+ state: "completed",
3177
+ path: "/tmp/image",
3178
+ },
3179
+ },
3180
+ ],
3181
+ cursor: {},
3182
+ }),
3183
+ event("session.model.selected", {
3184
+ sessionID: SESSION,
3185
+ model: { providerID: "opencode", id: "big-pickle", variant: "recovery-observed" },
3186
+ }),
3187
+ ],
3188
+ {
3189
+ fileSystem: {
3190
+ ...fs,
3191
+ stat: (path) =>
3192
+ path === "/tmp/image.png"
3193
+ ? Deferred.succeed(reading, undefined).pipe(
3194
+ Effect.andThen(Effect.never),
3195
+ Effect.onInterrupt(() => Deferred.succeed(interrupted, undefined)),
3196
+ )
3197
+ : fs.stat(path),
3198
+ },
3199
+ },
3200
+ );
3201
+ const events = yield* runtime.events.pipe(
3202
+ Stream.takeUntil(
3203
+ (e) =>
3204
+ e.type === "provider_thread.updated" &&
3205
+ e.providerThread.nativeMetadata?.modelSelection?.options?.some(
3206
+ (option) => option.value === "recovery-observed",
3207
+ ) === true,
3208
+ ),
3209
+ Stream.runCollect,
3210
+ Effect.forkScoped,
3211
+ );
3212
+ yield* runtime.startTurn(turnInput(thread));
3213
+ yield* Deferred.await(reading);
3214
+ yield* TestClock.adjust("5 seconds");
3215
+ yield* Deferred.await(interrupted);
3216
+ const collected = yield* Fiber.join(events);
3217
+ assert.isTrue(
3218
+ collected.some(
3219
+ (e) =>
3220
+ e.type === "turn_item.updated" &&
3221
+ e.turnItem.nativeItemRef?.nativeId === "call-image-slow" &&
3222
+ e.turnItem.status === "completed",
3223
+ ),
3224
+ );
3225
+ assert.isFalse(yield* runtime.hasPendingBackgroundWorkForThread!(thread));
3226
+ }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
3227
+ );
3228
+
3229
+ it.effect.each(["root", "child"] as const)(
3230
+ "settles %s native image tasks when reconnect attempts fail",
3231
+ (owner) =>
3232
+ Effect.gen(function* () {
3233
+ const attempts = yield* Effect.forEach([0, 1, 2, 3, 4], () => Deferred.make<void>());
3234
+ let count = 0;
3235
+ let failures = 0;
3236
+ const borrowers = {
3237
+ get current() {
3238
+ return count;
3239
+ },
3240
+ set current(next: number) {
3241
+ if (next < count && count === 2) {
3242
+ const attempt = attempts[failures++];
3243
+ if (attempt !== undefined) Deferred.doneUnsafe(attempt, Effect.void);
3244
+ }
3245
+ count = next;
3246
+ },
3247
+ };
3248
+ const tool = {
3249
+ sessionID: owner === "root" ? SESSION : CHILD,
3250
+ assistantMessageID: "msg_assistant",
3251
+ id: "call-image-lost",
3252
+ };
3253
+ const { runtime, thread } = yield* resumed(
3254
+ [
3255
+ ...(owner === "root"
3256
+ ? [out("session.prompt", { sessionID: SESSION, text: "<any>" }), promptAccepted]
3257
+ : [
3258
+ ...backgroundLaunch(CHILD),
3259
+ event("session.execution.started", { sessionID: CHILD }),
3260
+ ]),
3261
+ event("session.tool.input.started", { ...tool, name: "experimental_image_generate" }),
3262
+ event(
3263
+ "session.tool.success",
3264
+ {
3265
+ ...tool,
3266
+ content: [{ type: "text", text: "Launched" }],
3267
+ metadata: { jobID: "image_lost", path: "/tmp/image", model: "test/image" },
3268
+ executed: false,
3269
+ },
3270
+ undefined,
3271
+ 2,
3272
+ ),
3273
+ ...(owner === "child"
3274
+ ? [event("session.execution.succeeded", { sessionID: CHILD })]
3275
+ : []),
3276
+ event("session.execution.succeeded", { sessionID: SESSION }),
3277
+ { type: "runtime_exit", status: "success" },
3278
+ ],
3279
+ { borrowers },
3280
+ );
3281
+ const events = yield* runtime.events.pipe(Stream.runCollect, Effect.forkScoped);
3282
+ yield* runtime.startTurn(withLineage(thread));
3283
+ yield* Deferred.await(attempts[0]!);
3284
+ for (const attempt of attempts.slice(1)) {
3285
+ yield* TestClock.adjust("2 seconds");
3286
+ yield* Deferred.await(attempt);
3287
+ }
3288
+ const collected = yield* Fiber.join(events);
3289
+ assert.isFalse(yield* runtime.hasPendingBackgroundWorkForThread!(thread));
3290
+ assert.isTrue(
3291
+ collected.some(
3292
+ (e) =>
3293
+ e.type === "turn_item.updated" &&
3294
+ e.turnItem.nativeItemRef?.nativeId ===
3295
+ (owner === "root" ? tool.id : `${CHILD}:${tool.id}`) &&
3296
+ e.turnItem.status === "failed",
3297
+ ),
3298
+ );
3299
+ const rootSnapshots = collected.flatMap((e) =>
3300
+ e.type === "provider_thread.updated" && e.providerThread.id === thread.id ? [e] : [],
3301
+ );
3302
+ assert.isFalse(rootSnapshots.at(-1)?.pendingBackgroundWork);
3303
+ assert.deepEqual(rootSnapshots.at(-1)?.providerThread.pendingBackgroundTasks, []);
3304
+ assert.isTrue(
3305
+ rootSnapshots.some((e) =>
3306
+ e.providerThread.pendingBackgroundTasks?.some((task) => task.taskId === "image_lost"),
3307
+ ),
3308
+ );
3309
+ }).pipe(Effect.scoped),
3310
+ );
3311
+
3312
it.effect("projects successful native todo updates into one checklist", () =>
3313
Effect.gen(function* () {
3314
const updates = [