@northflare/runner 0.0.17 → 0.0.20

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

@@ -1,18 +0,0 @@
-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" | "xhigh";
-
-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

@@ -1,6 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,225 +0,0 @@
-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,
-      },
-    },
-  };
-}