Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

5.6 KB
Raw Blame
import { assert, it } from "@effect/vitest";
import * as Schema from "effect/Schema";

import * as CodexSchema from "./schema.ts";

const isGetAccountResponse = Schema.is(CodexSchema.V2GetAccountResponse);

const isThreadReadResponse = Schema.is(CodexSchema.V2ThreadReadResponse);

const isThreadResumeResponse = Schema.is(CodexSchema.V2ThreadResumeResponse);

const isThreadRollbackResponse = Schema.is(CodexSchema.V2ThreadRollbackResponse);

const isThreadForkResponse = Schema.is(CodexSchema.V2ThreadForkResponse);

const isThreadListResponse = Schema.is(CodexSchema.V2ThreadListResponse);

const isTurnCompletedNotification = Schema.is(CodexSchema.V2TurnCompletedNotification);

const isServerCollabTool = Schema.is(CodexSchema.ServerNotification__CollabAgentTool);

const isResumeCollabTool = Schema.is(CodexSchema.V2ThreadResumeResponse__CollabAgentTool);

const isServerCollabStatus = Schema.is(CodexSchema.ServerNotification__CollabAgentToolCallStatus);

const isResumeCollabStatus = Schema.is(
  CodexSchema.V2ThreadResumeResponse__CollabAgentToolCallStatus,
);

const decodeThreadResumeResponse = Schema.decodeUnknownSync(CodexSchema.V2ThreadResumeResponse);

const isSubAgentActivityKindCompleted = [
  Schema.is(CodexSchema.ServerNotification__SubAgentActivityKind),
  Schema.is(CodexSchema.V2ItemStartedNotification__SubAgentActivityKind),
  Schema.is(CodexSchema.V2ItemCompletedNotification__SubAgentActivityKind),
  Schema.is(CodexSchema.V2ThreadReadResponse__SubAgentActivityKind),
  Schema.is(CodexSchema.V2ThreadResumeResponse__SubAgentActivityKind),
];

it("accepts Codex 0.150 multi-agent values", () => {
  for (const isKind of isSubAgentActivityKindCompleted) {
    assert.equal(isKind("completed"), true);
  }

  for (const tool of ["sendMessage", "followupTask", "interruptAgent", "listAgents"]) {
    assert.equal(isServerCollabTool(tool), true);
    assert.equal(isResumeCollabTool(tool), true);
  }

  assert.equal(isServerCollabStatus("interrupted"), true);
  assert.equal(isResumeCollabStatus("interrupted"), true);

  const resumeResponse = {
    approvalPolicy: "never",
    approvalsReviewer: "user",
    cwd: "/tmp/project",
    model: "gpt-5.6-sol",
    modelProvider: "openai",
    sandbox: { type: "dangerFullAccess" },
    thread: {
      cliVersion: "0.150.0",
      createdAt: 0,
      cwd: "/tmp/project",
      ephemeral: false,
      id: "root-thread",
      modelProvider: "openai",
      preview: "",
      sessionId: "session-1",
      source: "cli",
      status: { type: "idle" },
      turns: [
        {
          id: "turn-1",
          status: "completed",
          items: [
            {
              agentsStates: {},
              id: "item-1",
              receiverThreadIds: ["child-thread"],
              senderThreadId: "root-thread",
              status: "interrupted",
              tool: "followupTask",
              type: "collabAgentToolCall",
            },
          ],
        },
      ],
      updatedAt: 0,
    },
  };

  assert.equal(isThreadResumeResponse(resumeResponse), true);
});

it("accepts Codex 0.150 account plan values", () => {
  const planTypes = [
    "self_serve_business_prolite",
    "ent26",
    "enterprise_cbp_automation",
    "edu_plus",
    "edu_pro",
  ];

  for (const planType of planTypes) {
    const accountResponse = {
      account: {
        email: "[email protected]",
        planType,
        type: "chatgpt",
      },
      requiresOpenaiAuth: true,
    };

    assert.equal(isGetAccountResponse(accountResponse), true);
  }
});

const failedThread = (codexErrorInfo: string, message: string) => ({
  cliVersion: "0.150.0",
  createdAt: 0,
  cwd: "/tmp/project",
  ephemeral: false,
  id: "thread-1",
  modelProvider: "openai",
  preview: "",
  sessionId: "session-1",
  source: "cli",
  status: { type: "idle" },
  turns: [
    {
      error: {
        codexErrorInfo,
        message,
      },
      id: "turn-1",
      items: [],
      status: "failed",
    },
  ],
  updatedAt: 0,
});

const resumeLikeResponse = (thread: ReturnType<typeof failedThread>) => ({
  approvalPolicy: "never",
  approvalsReviewer: "user",
  cwd: "/tmp/project",
  model: "gpt-5.6-sol",
  modelProvider: "openai",
  sandbox: { type: "dangerFullAccess" },
  thread,
});

it("accepts Codex rate limit errors for thread responses", () => {
  const thread = failedThread("rateLimitExceeded", "Rate limit exceeded");
  assert.equal(isThreadReadResponse({ thread }), true);
  assert.equal(isThreadResumeResponse(resumeLikeResponse(thread)), true);
  assert.equal(isThreadRollbackResponse({ thread }), true);
  assert.equal(isThreadListResponse({ data: [thread] }), true);
});

it("accepts Codex misalignment policy errors for thread responses", () => {
  const thread = failedThread("misalignmentPolicyViolation", "Misalignment policy violation");
  const resumeResponse = resumeLikeResponse(thread);
  assert.equal(isThreadReadResponse({ thread }), true);
  assert.equal(isThreadResumeResponse(resumeResponse), true);
  assert.equal(isThreadRollbackResponse({ thread }), true);
  assert.equal(isThreadForkResponse(resumeResponse), true);
  assert.equal(isThreadListResponse({ data: [thread] }), true);
  const decodedResume = decodeThreadResumeResponse(resumeResponse);
  assert.equal(decodedResume.thread.turns[0]?.error?.codexErrorInfo, "misalignmentPolicyViolation");
  assert.equal(
    isTurnCompletedNotification({
      threadId: "thread-1",
      turn: {
        error: {
          codexErrorInfo: "misalignmentPolicyViolation",
          message: "Misalignment policy violation",
        },
        id: "turn-1",
        items: [],
        status: "failed",
      },
    }),
    true,
  );
});