sailfork / t3code-github / packages/ effect-codex-app-server/ src/ schema.test.ts

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 isThreadForkResponse = Schema.is(CodexSchema.V2ThreadForkResponse);
const isTurnCompletedNotification = Schema.is(CodexSchema.V2TurnCompletedNotification);
const decodeThreadResumeResponse = Schema.decodeUnknownSync(CodexSchema.V2ThreadResumeResponse);

it("keeps async questions in live notifications and thread history", () => {
  const item = {
    type: "agentMessage",
    id: "question-1",
    text: "Which package?\n- pnpm\n- npm\n\nWhat should it be named?",
    phase: "final_answer",
    delivery: "async",
    questions: [
      { title: "Which package manager?", options: ["pnpm", "npm"] },
      { title: "What should it be named?" },
    ],
  } as const;
  for (const schema of [
    CodexSchema.ServerNotification__ThreadItem,
    CodexSchema.V2ItemStartedNotification__ThreadItem,
    CodexSchema.V2ItemCompletedNotification__ThreadItem,
    CodexSchema.V2ThreadReadResponse__ThreadItem,
    CodexSchema.V2ThreadResumeResponse__ThreadItem,
  ]) {
    assert.deepEqual(Schema.decodeSync(schema)(item), item);
  }
});

it("keeps partial answers in notifications and persisted thread histories", () => {
  const item = {
    type: "agentMessage",
    id: "partial-1",
    text: "A stable answer before more tool work.",
    phase: "partial_answer",
  } as const;
  for (const schema of [
    CodexSchema.ServerNotification__ThreadItem,
    CodexSchema.V2ItemStartedNotification__ThreadItem,
    CodexSchema.V2ItemCompletedNotification__ThreadItem,
    CodexSchema.V2ThreadReadResponse__ThreadItem,
    CodexSchema.V2ThreadResumeResponse__ThreadItem,
    CodexSchema.V2ThreadForkResponse__ThreadItem,
    CodexSchema.V2TurnCompletedNotification__ThreadItem,
  ]) {
    assert.deepEqual(Schema.decodeSync(schema)(item), item);
  }
  const response = {
    approvalPolicy: "never",
    approvalsReviewer: "user",
    cwd: "/tmp/project",
    model: "gpt-5.6-sol",
    modelProvider: "openai",
    sandbox: { type: "dangerFullAccess" },
    thread: {
      cliVersion: "0.162.0",
      createdAt: 0,
      updatedAt: 0,
      cwd: "/tmp/project",
      ephemeral: false,
      id: "thread-1",
      modelProvider: "openai",
      preview: "",
      projectId: null,
      sessionId: "session-1",
      source: "cli",
      status: { type: "idle" },
      turns: [{ id: "turn-1", status: "completed", items: [item] }],
    },
  };
  assert.equal(isThreadForkResponse(response), true);
  assert.equal(isThreadResumeResponse(response), true);
  assert.equal(isThreadReadResponse({ thread: response.thread }), true);
});

it("accepts Codex 0.150 multi-agent values", () => {
  const schemas = [
    CodexSchema.ServerNotification__SubAgentActivityKind,
    CodexSchema.V2ItemStartedNotification__SubAgentActivityKind,
    CodexSchema.V2ItemCompletedNotification__SubAgentActivityKind,
    CodexSchema.V2ThreadReadResponse__SubAgentActivityKind,
    CodexSchema.V2ThreadResumeResponse__SubAgentActivityKind,
  ];

  for (const schema of schemas) {
    assert.equal(Schema.is(schema)("completed"), true);
  }
  const isServerNotificationCollabAgentTool = Schema.is(
    CodexSchema.ServerNotification__CollabAgentTool,
  );

  const isV2ThreadResumeResponseCollabAgentTool = Schema.is(
    CodexSchema.V2ThreadResumeResponse__CollabAgentTool,
  );

  for (const tool of ["sendMessage", "followupTask", "interruptAgent", "listAgents"]) {
    assert.equal(isServerNotificationCollabAgentTool(tool), true);
    assert.equal(isV2ThreadResumeResponseCollabAgentTool(tool), true);
  }
  const isServerNotificationCollabAgentToolCallStatus = Schema.is(
    CodexSchema.ServerNotification__CollabAgentToolCallStatus,
  );

  assert.equal(isServerNotificationCollabAgentToolCallStatus("interrupted"), true);
  const isV2ThreadResumeResponseCollabAgentToolCallStatus = Schema.is(
    CodexSchema.V2ThreadResumeResponse__CollabAgentToolCallStatus,
  );

  assert.equal(isV2ThreadResumeResponseCollabAgentToolCallStatus("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: "",
      projectId: null,
      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,
    },
  };
  const isV2ThreadResumeResponse = Schema.is(CodexSchema.V2ThreadResumeResponse);

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

it("accepts Codex misalignment policy errors for thread responses", () => {
  const failedThread = {
    cliVersion: "0.150.0",
    createdAt: 0,
    cwd: "/tmp/project",
    ephemeral: false,
    id: "thread-1",
    modelProvider: "openai",
    preview: "",
    projectId: null,
    sessionId: "session-1",
    source: "cli",
    status: { type: "idle" },
    turns: [
      {
        error: {
          codexErrorInfo: "misalignmentPolicyViolation",
          message: "Misalignment policy violation",
        },
        id: "turn-1",
        items: [],
        status: "failed",
      },
    ],
    updatedAt: 0,
  };
  const resumeLikeResponse = {
    approvalPolicy: "never",
    approvalsReviewer: "user",
    cwd: "/tmp/project",
    model: "gpt-5.6-sol",
    modelProvider: "openai",
    sandbox: { type: "dangerFullAccess" },
    thread: failedThread,
  };
  assert.equal(isThreadReadResponse({ thread: failedThread }), true);
  assert.equal(isThreadResumeResponse(resumeLikeResponse), true);
  assert.equal(isThreadForkResponse(resumeLikeResponse), true);
  const decodedResume = decodeThreadResumeResponse(resumeLikeResponse);
  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,
  );
});

it("accepts account plan slugs newer than the pinned protocol", () => {
  const planTypes = [
    "self_serve_business_prolite",
    "ent26",
    "enterprise_cbp_automation",
    "edu_plus",
    "edu_pro",
    "promax",
    "some_future_plan",
  ];

  for (const planType of planTypes) {
    const accountResponse = {
      account: {
        email: "user@example.com",
        planType,
        type: "chatgpt",
      },
      requiresOpenaiAuth: true,
    };

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