import { describe, expect, it } from "@effect/vitest";import { Data, Effect, Exit } from "effect"; import { createExecutor, definePlugin } from "@executor-js/sdk";import { makeTestConfig } from "@executor-js/sdk/testing";import type { CodeExecutor, ExecuteResult } from "@executor-js/codemode-core"; import { createExecutionEngine, formatExecuteResult, formatPausedExecution } from "./engine";import { FormElicitation } from "@executor-js/sdk/core"; // Regression for the hang reported as the executor-MCP "180s timeout" against// Cowork (Claude web). Cowork goes down the `executeWithPause` branch because// it doesn't advertise managed elicitation. When the dynamic worker fails// fast (e.g. user submits TS with a `:` type annotation, "Unexpected token// ':'" inside ~25ms), the failure was swallowed and the request hung until// the client gave up at 180s. The cause was `Effect.race` having// prefer-success semantics in Effect v4: the racing pause-signal Deferred// never resolves, so a fiber failure is never observed by the racer. class FakeRuntimeError extends Data.TaggedError("FakeRuntimeError")<{  readonly message: string;}> {} const failingExecutor: CodeExecutor<FakeRuntimeError> = {  execute: () => Effect.fail(new FakeRuntimeError({ message: "Unexpected token ':'" })),}; const succeedingExecutor: CodeExecutor<FakeRuntimeError> = {  execute: () => Effect.succeed({ result: "ok", logs: [] } satisfies ExecuteResult),}; const emptyPlugin = definePlugin(() => ({  id: "empty-test" as const,  storage: () => ({}),  staticIntegrations: () => [],})); const makeExecutor = () => createExecutor(makeTestConfig({ plugins: [emptyPlugin()] as const })); describe("executeWithPause failure propagation", () => {  it.effect("surfaces a fast codeExecutor failure as an Exit.Failure", () =>    Effect.gen(function* () {      const executor = yield* makeExecutor();      const engine = createExecutionEngine({        executor,        codeExecutor: failingExecutor,      });       const exit = yield* Effect.exit(engine.executeWithPause("noop"));      expect(Exit.isFailure(exit)).toBe(true);    }),  );   it.effect("does not hang when codeExecutor fails", () =>    Effect.gen(function* () {      const executor = yield* makeExecutor();      const engine = createExecutionEngine({        executor,        codeExecutor: failingExecutor,      });       // Race the executeWithPause against a short sleep. With the bug      // present this resolves to "hung" because the failure is swallowed      // by the prefer-success race against the pause Deferred.      const outcome = yield* Effect.race(        Effect.exit(engine.executeWithPause("noop")).pipe(          Effect.map((exit) => ({ kind: "settled" as const, exit })),        ),        Effect.sleep("500 millis").pipe(Effect.as({ kind: "hung" as const })),      );       expect(outcome.kind).toBe("settled");    }),  );   it.effect("control: succeedingExecutor returns completed", () =>    Effect.gen(function* () {      const executor = yield* makeExecutor();      const engine = createExecutionEngine({        executor,        codeExecutor: succeedingExecutor,      });       const result = yield* engine.executeWithPause("noop");      expect(result.status).toBe("completed");    }),  );}); describe("pausedExecutionCount", () => {  it.effect("starts at zero", () =>    Effect.gen(function* () {      const executor = yield* makeExecutor();      const engine = createExecutionEngine({        executor,        codeExecutor: succeedingExecutor,      });       expect(yield* engine.pausedExecutionCount()).toBe(0);      expect(yield* engine.hasPausedExecutions()).toBe(false);    }),  );}); describe("formatPausedExecution approval terms", () => {  const paused = (request: FormElicitation) =>    ({      id: "exec_1",      elicitationContext: { address: "tools.x.org.default.y", args: {}, request },    }) as Parameters<typeof formatPausedExecution>[0];   it("states the terms an upstream attached to the approval", () => {    // An empty schema makes this look like a plain yes/no, but the metadata    // says accepting persists for the origin — so the answer differs, and the    // caller has to be able to see it.    const result = formatPausedExecution(      paused(        FormElicitation.make({          message: "Allow Browser use to access https://example.com?",          requestedSchema: {},          meta: { persist: "always", origin: "https://example.com" },        }),      ),    );     expect(result.text).toContain("Approval terms:");    expect(result.text).toContain('"persist": "always"');    expect((result.structured["interaction"] as { readonly meta?: unknown }).meta).toEqual({      persist: "always",      origin: "https://example.com",    });  });   it("says nothing about terms when the upstream attached none", () => {    const result = formatPausedExecution(      paused(FormElicitation.make({ message: "Proceed?", requestedSchema: {} })),    );     expect(result.text).not.toContain("Approval terms:");    expect((result.structured["interaction"] as Record<string, unknown>)["meta"]).toBeUndefined();  });}); // Pins the exact preview and structured shapes so the serialization dedupe in// the engine cannot drift them: the preview stays pretty-printed (indent 2),// truncation keeps its exact suffix, and structured carries the raw value.describe("formatExecuteResult output identity", () => {  const MAX_PREVIEW_CHARS = 30_000;   it("renders an object result as pretty-printed JSON and keeps the raw value in structured", () => {    const value = { café: "naïve — ✓", emoji: "🎉", nested: { π: 3.14159 } };    const formatted = formatExecuteResult({ result: value, logs: [] });     expect(formatted.text).toBe(JSON.stringify(value, null, 2));    expect(formatted.structured).toEqual({ status: "completed", result: value, logs: [] });    expect(formatted.structured["result"]).toBe(value);    expect(formatted.isError).toBe(false);  });   it("truncates a long preview with the exact suffix and untouched structured value", () => {    const value = { data: "é🎉".repeat(12_000) };    const pretty = JSON.stringify(value, null, 2);    expect(pretty.length).toBeGreaterThan(MAX_PREVIEW_CHARS);     const formatted = formatExecuteResult({ result: value });     expect(formatted.text).toBe(      `${pretty.slice(0, MAX_PREVIEW_CHARS)}\n... [truncated ${pretty.length - MAX_PREVIEW_CHARS} chars]`,    );    expect(formatted.structured["result"]).toBe(value);  });   it("returns a string result verbatim", () => {    const formatted = formatExecuteResult({ result: "plain — ✓", logs: ["l1", "l2"] });     expect(formatted.text).toBe("plain — ✓\n\nLogs:\nl1\nl2");    expect(formatted.structured).toEqual({      status: "completed",      result: "plain — ✓",      logs: ["l1", "l2"],    });  });   it("renders an error result with logs and truncation", () => {    const formatted = formatExecuteResult({      result: null,      error: "boom",      errorKind: "tool_error",      logs: ["x".repeat(MAX_PREVIEW_CHARS)],    });     const untruncated = `Error: boom\n\nLogs:\n${"x".repeat(MAX_PREVIEW_CHARS)}`;    expect(formatted.text).toBe(      `${untruncated.slice(0, MAX_PREVIEW_CHARS)}\n... [truncated ${untruncated.length - MAX_PREVIEW_CHARS} chars]`,    );    expect(formatted.isError).toBe(true);    expect(formatted.structured).toEqual({      status: "error",      error: "boom",      logs: ["x".repeat(MAX_PREVIEW_CHARS)],    });  });}); // The result-size span metric walks the whole result value with// `JSON.stringify`. A `toJSON` probe inside the fixture counts full walks:// every complete stringify of the value visits the probe exactly once.describe("execute outcome measurement cost", () => {  const instrumented = () => {    let walks = 0;    const probe = {      toJSON: () => {        walks += 1;        return "probe";      },    };    return { value: { data: [1, 2, 3], probe }, walks: () => walks };  };   const executorFor = (result: ExecuteResult): CodeExecutor<FakeRuntimeError> => ({    execute: () => Effect.succeed(result),  });   it.effect("walks the result value once on the pausable path", () =>    Effect.gen(function* () {      const executor = yield* makeExecutor();      const fixture = instrumented();      const engine = createExecutionEngine({        executor,        codeExecutor: executorFor({ result: fixture.value, logs: [] }),      });       const outcome = yield* engine.executeWithPause("noop");       expect(outcome.status).toBe("completed");      expect(fixture.walks()).toBe(1);    }),  );   it.effect("walks the result value once even when autoApprove stamps two spans", () =>    Effect.gen(function* () {      const executor = yield* makeExecutor();      const fixture = instrumented();      const engine = createExecutionEngine({        executor,        codeExecutor: executorFor({ result: fixture.value, logs: [] }),      });       // autoApprove runs the inline path (inner span annotation) and then      // annotates the outer pausable span with the same result.      const outcome = yield* engine.executeWithPause("noop", { autoApprove: true });       expect(outcome.status).toBe("completed");      expect(fixture.walks()).toBe(1);    }),  );   it.effect("a completed execution plus its preview pays two walks total", () =>    Effect.gen(function* () {      const executor = yield* makeExecutor();      const fixture = instrumented();      const engine = createExecutionEngine({        executor,        codeExecutor: executorFor({ result: fixture.value, logs: [] }),      });       const outcome = yield* engine.executeWithPause("noop");      expect(outcome.status).toBe("completed");      if (outcome.status !== "completed") return;       // One compact walk for the span size metric, one pretty walk for the      // preview. They produce different strings (compact vs indent 2), so      // neither can be derived from the other.      formatExecuteResult(outcome.result);      expect(fixture.walks()).toBe(2);    }),  );});