@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 111 lines 3.88 KB
Raw
1 import { describe, expect, it } from "vite-plus/test";
2 import type {
3 OrchestrationV2ProviderTurn,
4 OrchestrationV2Run,
5 OrchestrationV2RunAttempt,
6 OrchestrationV2ThreadProjection,
7 RunAttemptId,
8 RunId,
9 } from "@t3tools/contracts";
10
11 import { unsentManualContinuationSource } from "./orchestrationV2ManualContinuation.ts";
12
13 // The source only reads id/manualContinuationOfRunId on runs, runId+attemptOrdinal+reason+id
14 // on attempts, and runAttemptId on turns, so the fixtures carry just those fields.
15 const run = (id: string, manualContinuationOfRunId?: string) =>
16 ({ id, manualContinuationOfRunId }) as unknown as OrchestrationV2Run;
17
18 const attempt = (id: string, runId: string, ordinal: number, reason = "initial") =>
19 ({ id, runId, attemptOrdinal: ordinal, reason }) as unknown as OrchestrationV2RunAttempt;
20
21 const turn = (runAttemptId: string | null) =>
22 ({ runAttemptId: runAttemptId as RunAttemptId | null }) as OrchestrationV2ProviderTurn;
23
24 const projection = (
25 runs: OrchestrationV2Run[],
26 attempts: OrchestrationV2RunAttempt[],
27 providerTurns: OrchestrationV2ProviderTurn[],
28 ) =>
29 ({ runs, attempts, providerTurns }) as Pick<
30 OrchestrationV2ThreadProjection,
31 "runs" | "attempts" | "providerTurns"
32 >;
33
34 describe("unsentManualContinuationSource", () => {
35 it("returns undefined when the source run no longer exists", () => {
36 expect(
37 unsentManualContinuationSource(run("r2", "ghost" as RunId), projection([run("r2")], [], [])),
38 ).toBeUndefined();
39 });
40
41 it("returns the source run when it never had an accepted attempt", () => {
42 const source = run("src");
43 expect(
44 unsentManualContinuationSource(run("r2", "src" as RunId), projection([source], [], [])),
45 ).toBe(source);
46 });
47
48 it("returns undefined once the source attempt was accepted", () => {
49 const a1 = attempt("a1", "src", 1);
50 expect(
51 unsentManualContinuationSource(
52 run("r2", "src" as RunId),
53 projection([run("src")], [a1], [turn("a1")]),
54 ),
55 ).toBeUndefined();
56 });
57
58 it("returns the source when a steering restart ran after the accepted attempt", () => {
59 const source = run("src");
60 const a1 = attempt("a1", "src", 1);
61 const a2 = attempt("a2", "src", 2, "steering_restart");
62 expect(
63 unsentManualContinuationSource(
64 run("r2", "src" as RunId),
65 projection([source], [a1, a2], [turn("a1")]),
66 ),
67 ).toBe(source);
68 });
69
70 it("ignores a steering restart that predates the accepted attempt", () => {
71 const a1 = attempt("a1", "src", 1, "steering_restart");
72 const a2 = attempt("a2", "src", 2);
73 expect(
74 unsentManualContinuationSource(
75 run("r2", "src" as RunId),
76 projection([run("src")], [a1, a2], [turn("a2")]),
77 ),
78 ).toBeUndefined();
79 });
80
81 it("walks a chain of manual continuations until a source that never delivered", () => {
82 const root = run("root");
83 const mid = run("mid", "root" as RunId);
84 expect(
85 unsentManualContinuationSource(run("r3", "mid" as RunId), projection([root, mid], [], [])),
86 ).toBe(root);
87 });
88
89 it("stops the chain at a source whose attempt was accepted", () => {
90 const root = run("root");
91 const mid = run("mid", "root" as RunId);
92 const midAccepted = attempt("a-mid", "mid", 1);
93 const rootRestart = attempt("a-root", "root", 1, "steering_restart");
94 // mid's accepted attempt already delivered the forwarded message, so
95 // root's older steering restart is not still pending.
96 expect(
97 unsentManualContinuationSource(
98 run("r3", "mid" as RunId),
99 projection([root, mid], [midAccepted, rootRestart], [turn("a-mid")]),
100 ),
101 ).toBeUndefined();
102 });
103
104 it("stops on a cyclic continuation chain instead of looping", () => {
105 const a = run("a", "b" as RunId);
106 const b = run("b", "a" as RunId);
107 expect(
108 unsentManualContinuationSource(run("c", "a" as RunId), projection([a, b], [], [])),
109 ).toBeUndefined();
110 });
111 });