@northflare/runner 0.0.7 → 0.0.9

package/lib/codex-sdk/src/threadOptions.ts

@@ -0,0 +1,18 @@
+export type ApprovalMode = "never" | "on-request" | "on-failure" | "untrusted";
+
+export type SandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+
+export type ModelReasoningEffort = "minimal" | "low" | "medium" | "high";
+
+export type ThreadOptions = {
+  model?: string;
+  sandboxMode?: SandboxMode;
+  workingDirectory?: string;
+  skipGitRepoCheck?: boolean;
+  modelReasoningEffort?: ModelReasoningEffort;
+  networkAccessEnabled?: boolean;
+  webSearchEnabled?: boolean;
+  approvalPolicy?: ApprovalMode;
+  additionalDirectories?: string[];
+  configOverrides?: Record<string, unknown>;
+};

package/lib/codex-sdk/src/turnOptions.ts

@@ -0,0 +1,6 @@
+export type TurnOptions = {
+  /** JSON schema describing the expected agent output. */
+  outputSchema?: unknown;
+  /** AbortSignal to cancel the turn. */
+  signal?: AbortSignal;
+};

package/lib/codex-sdk/tests/abort.test.ts

@@ -0,0 +1,165 @@
+import path from "node:path";
+
+import { describe, expect, it } from "@jest/globals";
+
+import { Codex } from "../src/codex";
+
+import {
+  assistantMessage,
+  responseCompleted,
+  responseStarted,
+  shell_call as shellCall,
+  sse,
+  SseResponseBody,
+  startResponsesTestProxy,
+} from "./responsesProxy";
+
+const codexExecPath = path.join(process.cwd(), "..", "..", "codex-rs", "target", "debug", "codex");
+
+function* infiniteShellCall(): Generator<SseResponseBody> {
+  while (true) {
+    yield sse(responseStarted(), shellCall(), responseCompleted());
+  }
+}
+
+describe("AbortSignal support", () => {
+  it("aborts run() when signal is aborted", async () => {
+    const { url, close } = await startResponsesTestProxy({
+      statusCode: 200,
+      responseBodies: infiniteShellCall(),
+    });
+
+    try {
+      const client = new Codex({ codexPathOverride: codexExecPath, baseUrl: url, apiKey: "test" });
+      const thread = client.startThread();
+
+      // Create an abort controller and abort it immediately
+      const controller = new AbortController();
+      controller.abort("Test abort");
+
+      // The operation should fail because the signal is already aborted
+      await expect(thread.run("Hello, world!", { signal: controller.signal })).rejects.toThrow();
+    } finally {
+      await close();
+    }
+  });
+
+  it("aborts runStreamed() when signal is aborted", async () => {
+    const { url, close } = await startResponsesTestProxy({
+      statusCode: 200,
+      responseBodies: infiniteShellCall(),
+    });
+
+    try {
+      const client = new Codex({ codexPathOverride: codexExecPath, baseUrl: url, apiKey: "test" });
+      const thread = client.startThread();
+
+      // Create an abort controller and abort it immediately
+      const controller = new AbortController();
+      controller.abort("Test abort");
+
+      const { events } = await thread.runStreamed("Hello, world!", { signal: controller.signal });
+
+      // Attempting to iterate should fail
+      let iterationStarted = false;
+      try {
+        for await (const event of events) {
+          iterationStarted = true;
+          // Should not get here
+          expect(event).toBeUndefined();
+        }
+        // If we get here, the test should fail
+        throw new Error(
+          "Expected iteration to throw due to aborted signal, but it completed successfully",
+        );
+      } catch (error) {
+        // We expect an error to be thrown
+        expect(iterationStarted).toBe(false); // Should fail before any iteration
+        expect(error).toBeDefined();
+      }
+    } finally {
+      await close();
+    }
+  });
+
+  it("aborts run() when signal is aborted during execution", async () => {
+    const { url, close } = await startResponsesTestProxy({
+      statusCode: 200,
+      responseBodies: infiniteShellCall(),
+    });
+
+    try {
+      const client = new Codex({ codexPathOverride: codexExecPath, baseUrl: url, apiKey: "test" });
+      const thread = client.startThread();
+
+      const controller = new AbortController();
+
+      // Start the operation and abort it immediately after
+      const runPromise = thread.run("Hello, world!", { signal: controller.signal });
+
+      // Abort after a tiny delay to simulate aborting during execution
+      setTimeout(() => controller.abort("Aborted during execution"), 10);
+
+      // The operation should fail
+      await expect(runPromise).rejects.toThrow();
+    } finally {
+      await close();
+    }
+  });
+
+  it("aborts runStreamed() when signal is aborted during iteration", async () => {
+    const { url, close } = await startResponsesTestProxy({
+      statusCode: 200,
+      responseBodies: infiniteShellCall(),
+    });
+
+    try {
+      const client = new Codex({ codexPathOverride: codexExecPath, baseUrl: url, apiKey: "test" });
+      const thread = client.startThread();
+
+      const controller = new AbortController();
+
+      const { events } = await thread.runStreamed("Hello, world!", { signal: controller.signal });
+
+      // Abort during iteration
+      let eventCount = 0;
+      await expect(
+        (async () => {
+          for await (const event of events) {
+            void event; // Consume the event
+            eventCount++;
+            // Abort after first event
+            if (eventCount === 5) {
+              controller.abort("Aborted during iteration");
+            }
+            // Continue iterating - should eventually throw
+          }
+        })(),
+      ).rejects.toThrow();
+    } finally {
+      await close();
+    }
+  });
+
+  it("completes normally when signal is not aborted", async () => {
+    const { url, close } = await startResponsesTestProxy({
+      statusCode: 200,
+      responseBodies: [sse(responseStarted(), assistantMessage("Hi!"), responseCompleted())],
+    });
+
+    try {
+      const client = new Codex({ codexPathOverride: codexExecPath, baseUrl: url, apiKey: "test" });
+      const thread = client.startThread();
+
+      const controller = new AbortController();
+
+      // Don't abort - should complete successfully
+      const result = await thread.run("Hello, world!", { signal: controller.signal });
+
+      expect(result.finalResponse).toBe("Hi!");
+      expect(result.items).toHaveLength(1);
+    } finally {
+      await close();
+    }
+  });
+});

package/lib/codex-sdk/tests/codexExecSpy.ts

@@ -0,0 +1,37 @@
+import * as child_process from "node:child_process";
+
+jest.mock("node:child_process", () => {
+  const actual = jest.requireActual<typeof import("node:child_process")>("node:child_process");
+  return { ...actual, spawn: jest.fn(actual.spawn) };
+});
+
+const actualChildProcess =
+  jest.requireActual<typeof import("node:child_process")>("node:child_process");
+const spawnMock = child_process.spawn as jest.MockedFunction<typeof actualChildProcess.spawn>;
+
+export function codexExecSpy(): {
+  args: string[][];
+  envs: (Record<string, string> | undefined)[];
+  restore: () => void;
+} {
+  const previousImplementation = spawnMock.getMockImplementation() ?? actualChildProcess.spawn;
+  const args: string[][] = [];
+  const envs: (Record<string, string> | undefined)[] = [];
+
+  spawnMock.mockImplementation(((...spawnArgs: Parameters<typeof child_process.spawn>) => {
+    const commandArgs = spawnArgs[1];
+    args.push(Array.isArray(commandArgs) ? [...commandArgs] : []);
+    const options = spawnArgs[2] as child_process.SpawnOptions | undefined;
+    envs.push(options?.env as Record<string, string> | undefined);
+    return previousImplementation(...spawnArgs);
+  }) as typeof actualChildProcess.spawn);
+
+  return {
+    args,
+    envs,
+    restore: () => {
+      spawnMock.mockClear();
+      spawnMock.mockImplementation(previousImplementation);
+    },
+  };
+}

package/lib/codex-sdk/tests/responsesProxy.ts

@@ -0,0 +1,225 @@
+import http from "node:http";
+
+const DEFAULT_RESPONSE_ID = "resp_mock";
+const DEFAULT_MESSAGE_ID = "msg_mock";
+
+type ResponseCompletedUsage = {
+  input_tokens: number;
+  input_tokens_details: { cached_tokens: number } | null;
+  output_tokens: number;
+  output_tokens_details: { reasoning_tokens: number } | null;
+  total_tokens: number;
+};
+
+const DEFAULT_COMPLETED_USAGE: ResponseCompletedUsage = {
+  input_tokens: 42,
+  input_tokens_details: { cached_tokens: 12 },
+  output_tokens: 5,
+  output_tokens_details: null,
+  total_tokens: 47,
+};
+
+export type SseEvent = {
+  type: string;
+  [key: string]: unknown;
+};
+
+export type SseResponseBody = {
+  kind: "sse";
+  events: SseEvent[];
+};
+
+export type ResponsesProxyOptions = {
+  responseBodies: Generator<SseResponseBody> | SseResponseBody[];
+  statusCode?: number;
+};
+
+export type ResponsesProxy = {
+  url: string;
+  close: () => Promise<void>;
+  requests: RecordedRequest[];
+};
+
+export type ResponsesApiRequest = {
+  model?: string;
+  input: Array<{
+    role: string;
+    content?: Array<{ type: string; text: string }>;
+  }>;
+  text?: {
+    format?: Record<string, unknown>;
+  };
+};
+
+export type RecordedRequest = {
+  body: string;
+  json: ResponsesApiRequest;
+  headers: http.IncomingHttpHeaders;
+};
+
+function formatSseEvent(event: SseEvent): string {
+  return `event: ${event.type}\n` + `data: ${JSON.stringify(event)}\n\n`;
+}
+
+export async function startResponsesTestProxy(
+  options: ResponsesProxyOptions,
+): Promise<ResponsesProxy> {
+  function* createGenerator(array: SseResponseBody[]): Generator<SseResponseBody> {
+    for (const elem of array) {
+      yield elem;
+    }
+    throw new Error("not enough responses provided");
+  }
+
+  const responseBodies: Generator<SseResponseBody> = Array.isArray(options.responseBodies)
+    ? createGenerator(options.responseBodies)
+    : options.responseBodies;
+
+  const requests: RecordedRequest[] = [];
+
+  function readRequestBody(req: http.IncomingMessage): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      req.on("data", (chunk) => {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+      });
+      req.on("end", () => {
+        resolve(Buffer.concat(chunks).toString("utf8"));
+      });
+      req.on("error", reject);
+    });
+  }
+
+  const server = http.createServer((req, res) => {
+    async function handle(): Promise<void> {
+      if (req.method === "POST" && req.url === "/responses") {
+        const body = await readRequestBody(req);
+        const json = JSON.parse(body);
+        requests.push({ body, json, headers: { ...req.headers } });
+
+        const status = options.statusCode ?? 200;
+        res.statusCode = status;
+        res.setHeader("content-type", "text/event-stream");
+
+        const responseBody = responseBodies.next().value;
+        for (const event of responseBody.events) {
+          res.write(formatSseEvent(event));
+        }
+        res.end();
+        return;
+      }
+
+      res.statusCode = 404;
+      res.end();
+    }
+
+    handle().catch(() => {
+      res.statusCode = 500;
+      res.end();
+    });
+  });
+
+  const url = await new Promise<string>((resolve, reject) => {
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Unable to determine proxy address"));
+        return;
+      }
+      server.off("error", reject);
+      const info = address;
+      resolve(`http://${info.address}:${info.port}`);
+    });
+    server.once("error", reject);
+  });
+
+  async function close(): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      server.close((err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  return { url, close, requests };
+}
+
+export function sse(...events: SseEvent[]): SseResponseBody {
+  return {
+    kind: "sse",
+    events,
+  };
+}
+
+export function responseStarted(responseId: string = DEFAULT_RESPONSE_ID): SseEvent {
+  return {
+    type: "response.created",
+    response: {
+      id: responseId,
+    },
+  };
+}
+
+export function assistantMessage(text: string, itemId: string = DEFAULT_MESSAGE_ID): SseEvent {
+  return {
+    type: "response.output_item.done",
+    item: {
+      type: "message",
+      role: "assistant",
+      id: itemId,
+      content: [
+        {
+          type: "output_text",
+          text,
+        },
+      ],
+    },
+  };
+}
+
+export function shell_call(): SseEvent {
+  const command = ["bash", "-lc", "echo 'Hello, world!'"];
+  return {
+    type: "response.output_item.done",
+    item: {
+      type: "function_call",
+      call_id: `call_id${Math.random().toString(36).slice(2)}`,
+      name: "shell",
+      arguments: JSON.stringify({
+        command,
+        timeout_ms: 100,
+      }),
+    },
+  };
+}
+
+export function responseFailed(errorMessage: string): SseEvent {
+  return {
+    type: "error",
+    error: { code: "rate_limit_exceeded", message: errorMessage },
+  };
+}
+
+export function responseCompleted(
+  responseId: string = DEFAULT_RESPONSE_ID,
+  usage: ResponseCompletedUsage = DEFAULT_COMPLETED_USAGE,
+): SseEvent {
+  const inputDetails = usage.input_tokens_details ? { ...usage.input_tokens_details } : null;
+  const outputDetails = usage.output_tokens_details ? { ...usage.output_tokens_details } : null;
+  return {
+    type: "response.completed",
+    response: {
+      id: responseId,
+      usage: {
+        input_tokens: usage.input_tokens,
+        input_tokens_details: inputDetails,
+        output_tokens: usage.output_tokens,
+        output_tokens_details: outputDetails,
+        total_tokens: usage.total_tokens,
+      },
+    },
+  };
+}