chad-code 1.3.1 → 1.3.2

package/test/session/message-v2.test.ts

@@ -1,570 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { MessageV2 } from "../../src/session/message-v2"
-
-const sessionID = "session"
-
-function userInfo(id: string): MessageV2.User {
-  return {
-    id,
-    sessionID,
-    role: "user",
-    time: { created: 0 },
-    agent: "user",
-    model: { providerID: "test", modelID: "test" },
-    tools: {},
-    mode: "",
-  } as unknown as MessageV2.User
-}
-
-function assistantInfo(id: string, parentID: string, error?: MessageV2.Assistant["error"]): MessageV2.Assistant {
-  return {
-    id,
-    sessionID,
-    role: "assistant",
-    time: { created: 0 },
-    error,
-    parentID,
-    modelID: "model",
-    providerID: "provider",
-    mode: "",
-    agent: "agent",
-    path: { cwd: "/", root: "/" },
-    cost: 0,
-    tokens: {
-      input: 0,
-      output: 0,
-      reasoning: 0,
-      cache: { read: 0, write: 0 },
-    },
-  } as unknown as MessageV2.Assistant
-}
-
-function basePart(messageID: string, id: string) {
-  return {
-    id,
-    sessionID,
-    messageID,
-  }
-}
-
-describe("session.message-v2.toModelMessage", () => {
-  test("filters out messages with no parts", () => {
-    const input: MessageV2.WithParts[] = [
-      {
-        info: userInfo("m-empty"),
-        parts: [],
-      },
-      {
-        info: userInfo("m-user"),
-        parts: [
-          {
-            ...basePart("m-user", "p1"),
-            type: "text",
-            text: "hello",
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([
-      {
-        role: "user",
-        content: [{ type: "text", text: "hello" }],
-      },
-    ])
-  })
-
-  test("filters out messages with only ignored parts", () => {
-    const messageID = "m-user"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: userInfo(messageID),
-        parts: [
-          {
-            ...basePart(messageID, "p1"),
-            type: "text",
-            text: "ignored",
-            ignored: true,
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([])
-  })
-
-  test("includes synthetic text parts", () => {
-    const messageID = "m-user"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: userInfo(messageID),
-        parts: [
-          {
-            ...basePart(messageID, "p1"),
-            type: "text",
-            text: "hello",
-            synthetic: true,
-          },
-        ] as MessageV2.Part[],
-      },
-      {
-        info: assistantInfo("m-assistant", messageID),
-        parts: [
-          {
-            ...basePart("m-assistant", "a1"),
-            type: "text",
-            text: "assistant",
-            synthetic: true,
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([
-      {
-        role: "user",
-        content: [{ type: "text", text: "hello" }],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "assistant" }],
-      },
-    ])
-  })
-
-  test("converts user text/file parts and injects compaction/subtask prompts", () => {
-    const messageID = "m-user"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: userInfo(messageID),
-        parts: [
-          {
-            ...basePart(messageID, "p1"),
-            type: "text",
-            text: "hello",
-          },
-          {
-            ...basePart(messageID, "p2"),
-            type: "text",
-            text: "ignored",
-            ignored: true,
-          },
-          {
-            ...basePart(messageID, "p3"),
-            type: "file",
-            mime: "image/png",
-            filename: "img.png",
-            url: "https://example.com/img.png",
-          },
-          {
-            ...basePart(messageID, "p4"),
-            type: "file",
-            mime: "text/plain",
-            filename: "note.txt",
-            url: "https://example.com/note.txt",
-          },
-          {
-            ...basePart(messageID, "p5"),
-            type: "file",
-            mime: "application/x-directory",
-            filename: "dir",
-            url: "https://example.com/dir",
-          },
-          {
-            ...basePart(messageID, "p6"),
-            type: "compaction",
-            auto: true,
-          },
-          {
-            ...basePart(messageID, "p7"),
-            type: "subtask",
-            prompt: "prompt",
-            description: "desc",
-            agent: "agent",
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "hello" },
-          {
-            type: "file",
-            mediaType: "image/png",
-            filename: "img.png",
-            data: "https://example.com/img.png",
-          },
-          { type: "text", text: "What did we do so far?" },
-          { type: "text", text: "The following tool was executed by the user" },
-        ],
-      },
-    ])
-  })
-
-  test("converts assistant tool completion into tool-call + tool-result messages and emits attachment message", () => {
-    const userID = "m-user"
-    const assistantID = "m-assistant"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: userInfo(userID),
-        parts: [
-          {
-            ...basePart(userID, "u1"),
-            type: "text",
-            text: "run tool",
-          },
-        ] as MessageV2.Part[],
-      },
-      {
-        info: assistantInfo(assistantID, userID),
-        parts: [
-          {
-            ...basePart(assistantID, "a1"),
-            type: "text",
-            text: "done",
-            metadata: { openai: { assistant: "meta" } },
-          },
-          {
-            ...basePart(assistantID, "a2"),
-            type: "tool",
-            callID: "call-1",
-            tool: "bash",
-            state: {
-              status: "completed",
-              input: { cmd: "ls" },
-              output: "ok",
-              title: "Bash",
-              metadata: {},
-              time: { start: 0, end: 1 },
-              attachments: [
-                {
-                  ...basePart(assistantID, "file-1"),
-                  type: "file",
-                  mime: "image/png",
-                  filename: "attachment.png",
-                  url: "https://example.com/attachment.png",
-                },
-              ],
-            },
-            metadata: { openai: { tool: "meta" } },
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([
-      {
-        role: "user",
-        content: [{ type: "text", text: "run tool" }],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "Tool bash returned an attachment:" },
-          {
-            type: "file",
-            mediaType: "image/png",
-            filename: "attachment.png",
-            data: "https://example.com/attachment.png",
-          },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [
-          { type: "text", text: "done", providerOptions: { openai: { assistant: "meta" } } },
-          {
-            type: "tool-call",
-            toolCallId: "call-1",
-            toolName: "bash",
-            input: { cmd: "ls" },
-            providerExecuted: undefined,
-            providerOptions: { openai: { tool: "meta" } },
-          },
-        ],
-      },
-      {
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: "call-1",
-            toolName: "bash",
-            output: { type: "text", value: "ok" },
-          },
-        ],
-      },
-    ])
-  })
-
-  test("replaces compacted tool output with placeholder", () => {
-    const userID = "m-user"
-    const assistantID = "m-assistant"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: userInfo(userID),
-        parts: [
-          {
-            ...basePart(userID, "u1"),
-            type: "text",
-            text: "run tool",
-          },
-        ] as MessageV2.Part[],
-      },
-      {
-        info: assistantInfo(assistantID, userID),
-        parts: [
-          {
-            ...basePart(assistantID, "a1"),
-            type: "tool",
-            callID: "call-1",
-            tool: "bash",
-            state: {
-              status: "completed",
-              input: { cmd: "ls" },
-              output: "this should be cleared",
-              title: "Bash",
-              metadata: {},
-              time: { start: 0, end: 1, compacted: 1 },
-            },
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([
-      {
-        role: "user",
-        content: [{ type: "text", text: "run tool" }],
-      },
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool-call",
-            toolCallId: "call-1",
-            toolName: "bash",
-            input: { cmd: "ls" },
-            providerExecuted: undefined,
-          },
-        ],
-      },
-      {
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: "call-1",
-            toolName: "bash",
-            output: { type: "text", value: "[Old tool result content cleared]" },
-          },
-        ],
-      },
-    ])
-  })
-
-  test("converts assistant tool error into error-text tool result", () => {
-    const userID = "m-user"
-    const assistantID = "m-assistant"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: userInfo(userID),
-        parts: [
-          {
-            ...basePart(userID, "u1"),
-            type: "text",
-            text: "run tool",
-          },
-        ] as MessageV2.Part[],
-      },
-      {
-        info: assistantInfo(assistantID, userID),
-        parts: [
-          {
-            ...basePart(assistantID, "a1"),
-            type: "tool",
-            callID: "call-1",
-            tool: "bash",
-            state: {
-              status: "error",
-              input: { cmd: "ls" },
-              error: "nope",
-              time: { start: 0, end: 1 },
-              metadata: {},
-            },
-            metadata: { openai: { tool: "meta" } },
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([
-      {
-        role: "user",
-        content: [{ type: "text", text: "run tool" }],
-      },
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool-call",
-            toolCallId: "call-1",
-            toolName: "bash",
-            input: { cmd: "ls" },
-            providerExecuted: undefined,
-            providerOptions: { openai: { tool: "meta" } },
-          },
-        ],
-      },
-      {
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: "call-1",
-            toolName: "bash",
-            output: { type: "error-text", value: "nope" },
-          },
-        ],
-      },
-    ])
-  })
-
-  test("filters assistant messages with non-abort errors", () => {
-    const assistantID = "m-assistant"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: assistantInfo(
-          assistantID,
-          "m-parent",
-          new MessageV2.APIError({ message: "boom", isRetryable: true }).toObject() as MessageV2.APIError,
-        ),
-        parts: [
-          {
-            ...basePart(assistantID, "a1"),
-            type: "text",
-            text: "should not render",
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([])
-  })
-
-  test("includes aborted assistant messages only when they have non-step-start/reasoning content", () => {
-    const assistantID1 = "m-assistant-1"
-    const assistantID2 = "m-assistant-2"
-
-    const aborted = new MessageV2.AbortedError({ message: "aborted" }).toObject() as MessageV2.Assistant["error"]
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: assistantInfo(assistantID1, "m-parent", aborted),
-        parts: [
-          {
-            ...basePart(assistantID1, "a1"),
-            type: "reasoning",
-            text: "thinking",
-            time: { start: 0 },
-          },
-          {
-            ...basePart(assistantID1, "a2"),
-            type: "text",
-            text: "partial answer",
-          },
-        ] as MessageV2.Part[],
-      },
-      {
-        info: assistantInfo(assistantID2, "m-parent", aborted),
-        parts: [
-          {
-            ...basePart(assistantID2, "b1"),
-            type: "step-start",
-          },
-          {
-            ...basePart(assistantID2, "b2"),
-            type: "reasoning",
-            text: "thinking",
-            time: { start: 0 },
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([
-      {
-        role: "assistant",
-        content: [
-          { type: "reasoning", text: "thinking", providerOptions: undefined },
-          { type: "text", text: "partial answer" },
-        ],
-      },
-    ])
-  })
-
-  test("splits assistant messages on step-start boundaries", () => {
-    const assistantID = "m-assistant"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: assistantInfo(assistantID, "m-parent"),
-        parts: [
-          {
-            ...basePart(assistantID, "p1"),
-            type: "text",
-            text: "first",
-          },
-          {
-            ...basePart(assistantID, "p2"),
-            type: "step-start",
-          },
-          {
-            ...basePart(assistantID, "p3"),
-            type: "text",
-            text: "second",
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "first" }],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "second" }],
-      },
-    ])
-  })
-
-  test("drops messages that only contain step-start parts", () => {
-    const assistantID = "m-assistant"
-
-    const input: MessageV2.WithParts[] = [
-      {
-        info: assistantInfo(assistantID, "m-parent"),
-        parts: [
-          {
-            ...basePart(assistantID, "p1"),
-            type: "step-start",
-          },
-        ] as MessageV2.Part[],
-      },
-    ]
-
-    expect(MessageV2.toModelMessage(input)).toStrictEqual([])
-  })
-})

package/test/session/retry.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { SessionRetry } from "../../src/session/retry"
-import { MessageV2 } from "../../src/session/message-v2"
-
-function apiError(headers?: Record<string, string>): MessageV2.APIError {
-  return new MessageV2.APIError({
-    message: "boom",
-    isRetryable: true,
-    responseHeaders: headers,
-  }).toObject() as MessageV2.APIError
-}
-
-describe("session.retry.delay", () => {
-  test("caps delay at 30 seconds when headers missing", () => {
-    const error = apiError()
-    const delays = Array.from({ length: 10 }, (_, index) => SessionRetry.delay(index + 1, error))
-    expect(delays).toStrictEqual([2000, 4000, 8000, 16000, 30000, 30000, 30000, 30000, 30000, 30000])
-  })
-
-  test("prefers retry-after-ms when shorter than exponential", () => {
-    const error = apiError({ "retry-after-ms": "1500" })
-    expect(SessionRetry.delay(4, error)).toBe(1500)
-  })
-
-  test("uses retry-after seconds when reasonable", () => {
-    const error = apiError({ "retry-after": "30" })
-    expect(SessionRetry.delay(3, error)).toBe(30000)
-  })
-
-  test("accepts http-date retry-after values", () => {
-    const date = new Date(Date.now() + 20000).toUTCString()
-    const error = apiError({ "retry-after": date })
-    const d = SessionRetry.delay(1, error)
-    expect(d).toBeGreaterThanOrEqual(19000)
-    expect(d).toBeLessThanOrEqual(20000)
-  })
-
-  test("ignores invalid retry hints", () => {
-    const error = apiError({ "retry-after": "not-a-number" })
-    expect(SessionRetry.delay(1, error)).toBe(2000)
-  })
-
-  test("ignores malformed date retry hints", () => {
-    const error = apiError({ "retry-after": "Invalid Date String" })
-    expect(SessionRetry.delay(1, error)).toBe(2000)
-  })
-
-  test("ignores past date retry hints", () => {
-    const pastDate = new Date(Date.now() - 5000).toUTCString()
-    const error = apiError({ "retry-after": pastDate })
-    expect(SessionRetry.delay(1, error)).toBe(2000)
-  })
-
-  test("uses retry-after values even when exceeding 10 minutes with headers", () => {
-    const error = apiError({ "retry-after": "50" })
-    expect(SessionRetry.delay(1, error)).toBe(50000)
-
-    const longError = apiError({ "retry-after-ms": "700000" })
-    expect(SessionRetry.delay(1, longError)).toBe(700000)
-  })
-
-  test("sleep caps delay to max 32-bit signed integer to avoid TimeoutOverflowWarning", async () => {
-    const controller = new AbortController()
-
-    const warnings: string[] = []
-    const originalWarn = process.emitWarning
-    process.emitWarning = (warning: string | Error) => {
-      warnings.push(typeof warning === "string" ? warning : warning.message)
-    }
-
-    const promise = SessionRetry.sleep(2_560_914_000, controller.signal)
-    controller.abort()
-
-    try {
-      await promise
-    } catch {}
-
-    process.emitWarning = originalWarn
-    expect(warnings.some((w) => w.includes("TimeoutOverflowWarning"))).toBe(false)
-  })
-})
-
-describe("session.message-v2.fromError", () => {
-  test.concurrent(
-    "converts ECONNRESET socket errors to retryable APIError",
-    async () => {
-      using server = Bun.serve({
-        port: 0,
-        idleTimeout: 8,
-        async fetch(req) {
-          return new Response(
-            new ReadableStream({
-              async pull(controller) {
-                controller.enqueue("Hello,")
-                await Bun.sleep(10000)
-                controller.enqueue(" World!")
-                controller.close()
-              },
-            }),
-            { headers: { "Content-Type": "text/plain" } },
-          )
-        },
-      })
-
-      const error = await fetch(new URL("/", server.url.origin))
-        .then((res) => res.text())
-        .catch((e) => e)
-
-      const result = MessageV2.fromError(error, { providerID: "test" })
-
-      expect(MessageV2.APIError.isInstance(result)).toBe(true)
-      expect((result as MessageV2.APIError).data.isRetryable).toBe(true)
-      expect((result as MessageV2.APIError).data.message).toBe("Connection reset by server")
-      expect((result as MessageV2.APIError).data.metadata?.code).toBe("ECONNRESET")
-      expect((result as MessageV2.APIError).data.metadata?.message).toInclude("socket connection")
-    },
-    15_000,
-  )
-
-  test("ECONNRESET socket error is retryable", () => {
-    const error = new MessageV2.APIError({
-      message: "Connection reset by server",
-      isRetryable: true,
-      metadata: { code: "ECONNRESET", message: "The socket connection was closed unexpectedly" },
-    }).toObject() as MessageV2.APIError
-
-    const retryable = SessionRetry.retryable(error)
-    expect(retryable).toBeDefined()
-    expect(retryable).toBe("Connection reset by server")
-  })
-})