Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

59.1 KB
Raw Blame
// This file was auto-generated by Fern from our API Definition.

import * as TrueForgeTypes from "../../src/api/index";
import { TrueForge } from "../../src/Client";
import { mockServerPool } from "../mock-server/MockServerPool";

describe("SessionsClient", () => {
    test("list (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = {
            data: [
                {
                    agent: { spec: { model: { name: "name" } }, type: "inline" },
                    created_at: "created_at",
                    created_by_subject: {
                        subject_display_name: "subject_display_name",
                        subject_id: "subject_id",
                        subject_type: "subject_type",
                    },
                    id: "id",
                    last_turn_details: { id: "id", state: { status: "running" } },
                    metadata: { key: "value" },
                    metrics: { total_duration_ms: 1, total_turns: 1 },
                    shared: true,
                    source: { id: "id", run_id: "run_id", type: "schedule" },
                    title: "title",
                    updated_at: "updated_at",
                },
            ],
            pagination: { limit: 1, next_page_token: "next_page_token", previous_page_token: "previous_page_token" },
        };

        server
            .mockEndpoint({ once: false })
            .get("/api/v1/sessions")
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const expected = {
            data: [
                {
                    agent: {
                        spec: {
                            model: {
                                name: "name",
                            },
                        },
                        type: "inline",
                    },
                    createdAt: "created_at",
                    createdBySubject: {
                        subjectDisplayName: "subject_display_name",
                        subjectId: "subject_id",
                        subjectType: "subject_type",
                    },
                    id: "id",
                    lastTurnDetails: {
                        id: "id",
                        state: {
                            status: "running",
                        },
                    },
                    metadata: {
                        key: "value",
                    },
                    metrics: {
                        totalDurationMs: 1,
                        totalTurns: 1,
                    },
                    shared: true,
                    source: {
                        id: "id",
                        runId: "run_id",
                        type: "schedule",
                    },
                    title: "title",
                    updatedAt: "updated_at",
                },
            ],
            pagination: {
                limit: 1,
                nextPageToken: "next_page_token",
                previousPageToken: "previous_page_token",
            },
        };
        const page = await client.sessions.list();

        expect(expected.data).toEqual(page.data);
        expect(page.hasNextPage()).toBe(true);
        const nextPage = await page.getNextPage();
        expect(expected.data).toEqual(nextPage.data);
    });

    test("list (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server.mockEndpoint().get("/api/v1/sessions").respondWith().statusCode(400).jsonBody(rawResponseBody).build();

        await expect(async () => {
            return await client.sessions.list();
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("create (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { agent: { name: "name" } };
        const rawResponseBody = {
            data: {
                agent: { spec: { model: { name: "name" } }, type: "inline" },
                created_at: "created_at",
                created_by_subject: {
                    subject_display_name: "subject_display_name",
                    subject_id: "subject_id",
                    subject_type: "subject_type",
                },
                id: "id",
                last_turn_details: { id: "id", state: { status: "running" } },
                metadata: { key: "value" },
                metrics: { total_cost_in_usd: 1.1, total_duration_ms: 1, total_turns: 1 },
                shared: true,
                source: { id: "id", run_id: "run_id", type: "schedule" },
                title: "title",
                updated_at: "updated_at",
            },
        };

        server
            .mockEndpoint()
            .post("/api/v1/sessions")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const response = await client.sessions.create({
            agent: {
                name: "name",
            },
        });
        expect(response).toEqual({
            data: {
                agent: {
                    spec: {
                        model: {
                            name: "name",
                        },
                    },
                    type: "inline",
                },
                createdAt: "created_at",
                createdBySubject: {
                    subjectDisplayName: "subject_display_name",
                    subjectId: "subject_id",
                    subjectType: "subject_type",
                },
                id: "id",
                lastTurnDetails: {
                    id: "id",
                    state: {
                        status: "running",
                    },
                },
                metadata: {
                    key: "value",
                },
                metrics: {
                    totalCostInUsd: 1.1,
                    totalDurationMs: 1,
                    totalTurns: 1,
                },
                shared: true,
                source: {
                    id: "id",
                    runId: "run_id",
                    type: "schedule",
                },
                title: "title",
                updatedAt: "updated_at",
            },
        });
    });

    test("create (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { agent: { name: "xy" } };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.create({
                agent: {
                    name: "xy",
                },
            });
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("create (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { agent: { name: "xy" } };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.create({
                agent: {
                    name: "xy",
                },
            });
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("create (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { agent: { name: "xy" } };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(422)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.create({
                agent: {
                    name: "xy",
                },
            });
        }).rejects.toThrow(TrueForgeTypes.UnprocessableEntityError);
    });

    test("get (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = {
            data: {
                agent: { spec: { model: { name: "name" } }, type: "inline" },
                created_at: "created_at",
                created_by_subject: {
                    subject_display_name: "subject_display_name",
                    subject_id: "subject_id",
                    subject_type: "subject_type",
                },
                id: "id",
                last_turn_details: { id: "id", state: { status: "running" } },
                metadata: { key: "value" },
                metrics: { total_cost_in_usd: 1.1, total_duration_ms: 1, total_turns: 1 },
                shared: true,
                source: { id: "id", run_id: "run_id", type: "schedule" },
                title: "title",
                updated_at: "updated_at",
            },
        };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id")
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const response = await client.sessions.get("session_id");
        expect(response).toEqual({
            data: {
                agent: {
                    spec: {
                        model: {
                            name: "name",
                        },
                    },
                    type: "inline",
                },
                createdAt: "created_at",
                createdBySubject: {
                    subjectDisplayName: "subject_display_name",
                    subjectId: "subject_id",
                    subjectType: "subject_type",
                },
                id: "id",
                lastTurnDetails: {
                    id: "id",
                    state: {
                        status: "running",
                    },
                },
                metadata: {
                    key: "value",
                },
                metrics: {
                    totalCostInUsd: 1.1,
                    totalDurationMs: 1,
                    totalTurns: 1,
                },
                shared: true,
                source: {
                    id: "id",
                    runId: "run_id",
                    type: "schedule",
                },
                title: "title",
                updatedAt: "updated_at",
            },
        });
    });

    test("get (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id")
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.get("session_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("get (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id")
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.get("session_id");
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("delete (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        server.mockEndpoint().delete("/api/v1/sessions/session_id").respondWith().statusCode(200).build();

        const response = await client.sessions.delete("session_id");
        expect(response).toEqual(undefined);
    });

    test("delete (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .delete("/api/v1/sessions/session_id")
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.delete("session_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("update (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = {
            data: {
                agent: { spec: { model: { name: "name" } }, type: "inline" },
                created_at: "created_at",
                created_by_subject: {
                    subject_display_name: "subject_display_name",
                    subject_id: "subject_id",
                    subject_type: "subject_type",
                },
                id: "id",
                last_turn_details: { id: "id", state: { status: "running" } },
                metadata: { key: "value" },
                metrics: { total_cost_in_usd: 1.1, total_duration_ms: 1, total_turns: 1 },
                shared: true,
                source: { id: "id", run_id: "run_id", type: "schedule" },
                title: "title",
                updated_at: "updated_at",
            },
        };

        server
            .mockEndpoint()
            .patch("/api/v1/sessions/session_id")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const response = await client.sessions.update("session_id");
        expect(response).toEqual({
            data: {
                agent: {
                    spec: {
                        model: {
                            name: "name",
                        },
                    },
                    type: "inline",
                },
                createdAt: "created_at",
                createdBySubject: {
                    subjectDisplayName: "subject_display_name",
                    subjectId: "subject_id",
                    subjectType: "subject_type",
                },
                id: "id",
                lastTurnDetails: {
                    id: "id",
                    state: {
                        status: "running",
                    },
                },
                metadata: {
                    key: "value",
                },
                metrics: {
                    totalCostInUsd: 1.1,
                    totalDurationMs: 1,
                    totalTurns: 1,
                },
                shared: true,
                source: {
                    id: "id",
                    runId: "run_id",
                    type: "schedule",
                },
                title: "title",
                updatedAt: "updated_at",
            },
        });
    });

    test("update (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .patch("/api/v1/sessions/session_id")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.update("session_id");
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("update (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .patch("/api/v1/sessions/session_id")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.update("session_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("update (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .patch("/api/v1/sessions/session_id")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.update("session_id");
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("update (5)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .patch("/api/v1/sessions/session_id")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(422)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.update("session_id");
        }).rejects.toThrow(TrueForgeTypes.UnprocessableEntityError);
    });

    test("cancel (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = {};

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/cancel")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const response = await client.sessions.cancel("session_id");
        expect(response).toEqual({});
    });

    test("cancel (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/cancel")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.cancel("session_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("cancel (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/cancel")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.cancel("session_id");
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("cancel (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = {};
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/cancel")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(412)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.cancel("session_id");
        }).rejects.toThrow(TrueForgeTypes.PreconditionFailedError);
    });

    test("list_events (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = {
            data: [
                {
                    event: {
                        created_at: "created_at",
                        id: "id",
                        thread_id: null,
                        mcp_servers: [{ auth_url: "auth_url", id: "id", name: "name" }],
                        type: "mcp.auth_required",
                    },
                    turn_id: "turn_id",
                },
            ],
            pagination: { limit: 1, next_page_token: "next_page_token", previous_page_token: "previous_page_token" },
        };

        server
            .mockEndpoint({ once: false })
            .get("/api/v1/sessions/session_id/events")
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const expected = {
            data: [
                {
                    event: {
                        createdAt: "created_at",
                        id: "id",
                        threadId: null,
                        mcpServers: [
                            {
                                authUrl: "auth_url",
                                id: "id",
                                name: "name",
                            },
                        ],
                        type: "mcp.auth_required",
                    },
                    turnId: "turn_id",
                },
            ],
            pagination: {
                limit: 1,
                nextPageToken: "next_page_token",
                previousPageToken: "previous_page_token",
            },
        };
        const page = await client.sessions.listEvents("session_id");

        expect(expected.data).toEqual(page.data);
        expect(page.hasNextPage()).toBe(true);
        const nextPage = await page.getNextPage();
        expect(expected.data).toEqual(nextPage.data);
    });

    test("list_events (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/events")
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listEvents("session_id");
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("list_events (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/events")
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listEvents("session_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("list_events (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/events")
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listEvents("session_id");
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("list_turns (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = {
            data: [
                {
                    created_at: "created_at",
                    id: "id",
                    input: [{ content: "content", type: "user.message" }],
                    previous_turn_id: "previous_turn_id",
                    session_id: "session_id",
                    state: { completed_at: "completed_at", reason: "server-execution-timeout", status: "cancelled" },
                },
            ],
            pagination: { limit: 1, next_page_token: "next_page_token", previous_page_token: "previous_page_token" },
        };

        server
            .mockEndpoint({ once: false })
            .get("/api/v1/sessions/session_id/turns")
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const expected = {
            data: [
                {
                    createdAt: "created_at",
                    id: "id",
                    input: [
                        {
                            content: "content",
                            type: "user.message",
                        },
                    ],
                    previousTurnId: "previous_turn_id",
                    sessionId: "session_id",
                    state: {
                        completedAt: "completed_at",
                        reason: "server-execution-timeout",
                        status: "cancelled",
                    },
                },
            ],
            pagination: {
                limit: 1,
                nextPageToken: "next_page_token",
                previousPageToken: "previous_page_token",
            },
        };
        const page = await client.sessions.listTurns("session_id");

        expect(expected.data).toEqual(page.data);
        expect(page.hasNextPage()).toBe(true);
        const nextPage = await page.getNextPage();
        expect(expected.data).toEqual(nextPage.data);
    });

    test("list_turns (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns")
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listTurns("session_id");
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("list_turns (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns")
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listTurns("session_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("list_turns (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns")
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listTurns("session_id");
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("create_turn_stream (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: true };
        const rawResponseBody =
            'event: \ndata: {"created_at":"created_at","id":"id","thread_id":"thread_id","mcp_servers":[{"auth_url":"auth_url","id":"id","name":"name"}],"type":"mcp.auth_required"}\n\n';

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(200)
            .sseBody(rawResponseBody)
            .build();

        const response = await client.sessions.createTurnStream("session_id", {});
        const events: unknown[] = [];
        for await (const event of response) {
            events.push(event);
        }
        expect(events).toEqual([
            {
                createdAt: "created_at",
                id: "id",
                threadId: "thread_id",
                mcpServers: [
                    {
                        authUrl: "auth_url",
                        id: "id",
                        name: "name",
                    },
                ],
                type: "mcp.auth_required",
            },
        ]);
    });

    test("create_turn_stream (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: true };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnStream("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("create_turn_stream (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: true };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(401)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnStream("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.UnauthorizedError);
    });

    test("create_turn_stream (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: true };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnStream("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("create_turn_stream (5)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: true };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnStream("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("create_turn_stream (6)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: true };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(412)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnStream("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.PreconditionFailedError);
    });

    test("create_turn_stream (7)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: true };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(413)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnStream("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.ContentTooLargeError);
    });

    test("create_turn_stream (8)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: true };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(422)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnStream("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.UnprocessableEntityError);
    });

    test("create_turn (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: false };
        const rawResponseBody = {
            data: {
                created_at: "created_at",
                id: "id",
                input: [{ content: "content", type: "user.message" }],
                previous_turn_id: "previous_turn_id",
                session_id: "session_id",
                state: { completed_at: "completed_at", reason: "server-execution-timeout", status: "cancelled" },
            },
        };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const response = await client.sessions.createTurn("session_id", {});
        expect(response).toEqual({
            data: {
                createdAt: "created_at",
                id: "id",
                input: [
                    {
                        content: "content",
                        type: "user.message",
                    },
                ],
                previousTurnId: "previous_turn_id",
                sessionId: "session_id",
                state: {
                    completedAt: "completed_at",
                    reason: "server-execution-timeout",
                    status: "cancelled",
                },
            },
        });
    });

    test("create_turn (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: false };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurn("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("create_turn (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: false };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(401)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurn("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.UnauthorizedError);
    });

    test("create_turn (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: false };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurn("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("create_turn (5)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: false };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurn("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("create_turn (6)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: false };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(412)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurn("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.PreconditionFailedError);
    });

    test("create_turn (7)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: false };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(413)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurn("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.ContentTooLargeError);
    });

    test("create_turn (8)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { stream: false };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(422)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurn("session_id", {});
        }).rejects.toThrow(TrueForgeTypes.UnprocessableEntityError);
    });

    test("get_turn (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = {
            data: {
                created_at: "created_at",
                id: "id",
                input: [{ content: "content", type: "user.message" }],
                previous_turn_id: "previous_turn_id",
                session_id: "session_id",
                state: { completed_at: "completed_at", reason: "server-execution-timeout", status: "cancelled" },
            },
        };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id")
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const response = await client.sessions.getTurn("session_id", "turn_id");
        expect(response).toEqual({
            data: {
                createdAt: "created_at",
                id: "id",
                input: [
                    {
                        content: "content",
                        type: "user.message",
                    },
                ],
                previousTurnId: "previous_turn_id",
                sessionId: "session_id",
                state: {
                    completedAt: "completed_at",
                    reason: "server-execution-timeout",
                    status: "cancelled",
                },
            },
        });
    });

    test("get_turn (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id")
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.getTurn("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("get_turn (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id")
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.getTurn("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("list_turn_events (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = {
            data: [
                {
                    created_at: "created_at",
                    id: "id",
                    thread_id: "thread_id",
                    mcp_servers: [{ auth_url: "auth_url", id: "id", name: "name" }],
                    type: "mcp.auth_required",
                },
            ],
            pagination: { limit: 1, next_page_token: "next_page_token", previous_page_token: "previous_page_token" },
        };

        server
            .mockEndpoint({ once: false })
            .get("/api/v1/sessions/session_id/turns/turn_id/events")
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const expected = {
            data: [
                {
                    createdAt: "created_at",
                    id: "id",
                    threadId: "thread_id",
                    mcpServers: [
                        {
                            authUrl: "auth_url",
                            id: "id",
                            name: "name",
                        },
                    ],
                    type: "mcp.auth_required",
                },
            ],
            pagination: {
                limit: 1,
                nextPageToken: "next_page_token",
                previousPageToken: "previous_page_token",
            },
        };
        const page = await client.sessions.listTurnEvents("session_id", "turn_id");

        expect(expected.data).toEqual(page.data);
        expect(page.hasNextPage()).toBe(true);
        const nextPage = await page.getNextPage();
        expect(expected.data).toEqual(nextPage.data);
    });

    test("list_turn_events (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id/events")
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listTurnEvents("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("list_turn_events (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id/events")
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listTurnEvents("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("list_turn_events (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id/events")
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.listTurnEvents("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("create_turn_event (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { events: [{ type: "user.mcp_auth_continue" }] };
        const rawResponseBody = { data: [{ created_at: "created_at", id: "id", type: "user.mcp_auth_continue" }] };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns/turn_id/events")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(200)
            .jsonBody(rawResponseBody)
            .build();

        const response = await client.sessions.createTurnEvent("session_id", "turn_id", {
            events: [
                {
                    type: "user.mcp_auth_continue",
                },
            ],
        });
        expect(response).toEqual({
            data: [
                {
                    createdAt: "created_at",
                    id: "id",
                    type: "user.mcp_auth_continue",
                },
            ],
        });
    });

    test("create_turn_event (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { events: [{ type: "user.mcp_auth_continue" }, { type: "user.mcp_auth_continue" }] };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns/turn_id/events")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnEvent("session_id", "turn_id", {
                events: [
                    {
                        type: "user.mcp_auth_continue",
                    },
                    {
                        type: "user.mcp_auth_continue",
                    },
                ],
            });
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("create_turn_event (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { events: [{ type: "user.mcp_auth_continue" }, { type: "user.mcp_auth_continue" }] };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns/turn_id/events")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnEvent("session_id", "turn_id", {
                events: [
                    {
                        type: "user.mcp_auth_continue",
                    },
                    {
                        type: "user.mcp_auth_continue",
                    },
                ],
            });
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("create_turn_event (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { events: [{ type: "user.mcp_auth_continue" }, { type: "user.mcp_auth_continue" }] };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns/turn_id/events")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnEvent("session_id", "turn_id", {
                events: [
                    {
                        type: "user.mcp_auth_continue",
                    },
                    {
                        type: "user.mcp_auth_continue",
                    },
                ],
            });
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("create_turn_event (5)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });
        const rawRequestBody = { events: [{ type: "user.mcp_auth_continue" }, { type: "user.mcp_auth_continue" }] };
        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .post("/api/v1/sessions/session_id/turns/turn_id/events")
            .jsonBody(rawRequestBody)
            .respondWith()
            .statusCode(409)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.createTurnEvent("session_id", "turn_id", {
                events: [
                    {
                        type: "user.mcp_auth_continue",
                    },
                    {
                        type: "user.mcp_auth_continue",
                    },
                ],
            });
        }).rejects.toThrow(TrueForgeTypes.ConflictError);
    });

    test("subscribe_to_turn (1)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody =
            'event: \ndata: {"created_at":"created_at","id":"id","thread_id":"thread_id","mcp_servers":[{"auth_url":"auth_url","id":"id","name":"name"}],"type":"mcp.auth_required"}\n\n';

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id/subscribe")
            .respondWith()
            .statusCode(200)
            .sseBody(rawResponseBody)
            .build();

        const response = await client.sessions.subscribeToTurn("session_id", "turn_id");
        const events: unknown[] = [];
        for await (const event of response) {
            events.push(event);
        }
        expect(events).toEqual([
            {
                createdAt: "created_at",
                id: "id",
                threadId: "thread_id",
                mcpServers: [
                    {
                        authUrl: "auth_url",
                        id: "id",
                        name: "name",
                    },
                ],
                type: "mcp.auth_required",
            },
        ]);
    });

    test("subscribe_to_turn (2)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id/subscribe")
            .respondWith()
            .statusCode(400)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.subscribeToTurn("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.BadRequestError);
    });

    test("subscribe_to_turn (3)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id/subscribe")
            .respondWith()
            .statusCode(403)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.subscribeToTurn("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.ForbiddenError);
    });

    test("subscribe_to_turn (4)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id/subscribe")
            .respondWith()
            .statusCode(404)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.subscribeToTurn("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.NotFoundError);
    });

    test("subscribe_to_turn (5)", async () => {
        const server = mockServerPool.createServer();
        const client = new TrueForge({ maxRetries: 0, token: "test", baseUrl: server.baseUrl });

        const rawResponseBody = { error: { message: "message" } };

        server
            .mockEndpoint()
            .get("/api/v1/sessions/session_id/turns/turn_id/subscribe")
            .respondWith()
            .statusCode(412)
            .jsonBody(rawResponseBody)
            .build();

        await expect(async () => {
            return await client.sessions.subscribeToTurn("session_id", "turn_id");
        }).rejects.toThrow(TrueForgeTypes.PreconditionFailedError);
    });
});