Client.ts

/**
 * This file was auto-generated by Fern from our API Definition.
 */

import * as environments from "../../../../environments";
import * as core from "../../../../core";
import * as Humanloop from "../../../index";
import * as serializers from "../../../../serialization/index";
import urlJoin from "url-join";
import * as errors from "../../../../errors/index";
import * as stream from "stream";

export declare namespace Agents {
    export interface Options {
        environment?: core.Supplier<environments.HumanloopEnvironment | string>;
        /** Specify a custom URL to connect the client to. */
        baseUrl?: core.Supplier<string>;
        apiKey?: core.Supplier<string>;
        fetcher?: core.FetchFunction;
    }

    export interface RequestOptions {
        /** The maximum time to wait for a response in seconds. */
        timeoutInSeconds?: number;
        /** The number of times to retry the request. Defaults to 2. */
        maxRetries?: number;
        /** A hook to abort the request. */
        abortSignal?: AbortSignal;
        /** Additional headers to include in the request. */
        headers?: Record<string, string>;
    }
}

export class Agents {
    constructor(protected readonly _options: Agents.Options = {}) {}

    /**
     * Create an Agent Log.
     *
     * You can use query parameters `version_id`, or `environment`, to target
     * an existing version of the Agent. Otherwise, the default deployed version will be chosen.
     *
     * If you create the Agent Log with a `log_status` of `incomplete`, you should later update it to `complete`
     * in order to trigger Evaluators.
     *
     * @param {Humanloop.AgentLogRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.log({
     *         path: "Banking/Teller Agent",
     *         agent: {
     *             provider: "anthropic",
     *             endpoint: "chat",
     *             model: "claude-3-7-sonnet-latest",
     *             reasoningEffort: 1024,
     *             template: [{
     *                     role: "system",
     *                     content: "You are a helpful digital assistant, helping users navigate our digital banking platform."
     *                 }],
     *             maxIterations: 3,
     *             tools: [{
     *                     type: "file",
     *                     link: {
     *                         fileId: "pr_1234567890",
     *                         versionId: "prv_1234567890"
     *                     },
     *                     onAgentCall: "continue"
     *                 }, {
     *                     type: "inline",
     *                     jsonSchema: {
     *                         name: "stop",
     *                         description: "Call this tool when you have finished your task.",
     *                         parameters: {
     *                             "type": "object",
     *                             "properties": {
     *                                 "output": {
     *                                     "type": "string",
     *                                     "description": "The final output to return to the user."
     *                                 }
     *                             },
     *                             "additionalProperties": false,
     *                             "required": [
     *                                 "output"
     *                             ]
     *                         },
     *                         strict: true
     *                     },
     *                     onAgentCall: "stop"
     *                 }]
     *         }
     *     })
     */
    public async log(
        request: Humanloop.AgentLogRequest = {},
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.CreateAgentLogResponse> {
        const { versionId, environment, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (versionId != null) {
            _queryParams["version_id"] = versionId;
        }

        if (environment != null) {
            _queryParams["environment"] = environment;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                "agents/log",
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: serializers.AgentLogRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.CreateAgentLogResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling POST /agents/log.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Update a Log.
     *
     * Update the details of a Log with the given ID.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {string} logId - Unique identifier for the Log.
     * @param {Humanloop.UpdateAgentLogRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.updateLog("ag_1234567890", "log_1234567890", {
     *         messages: [{
     *                 role: "user",
     *                 content: "I need to withdraw $1000"
     *             }, {
     *                 role: "assistant",
     *                 content: "Of course! Would you like to use your savings or checking account?"
     *             }],
     *         outputMessage: {
     *             role: "assistant",
     *             content: "I'm sorry, I can't help with that."
     *         },
     *         logStatus: "complete"
     *     })
     */
    public async updateLog(
        id: string,
        logId: string,
        request: Humanloop.UpdateAgentLogRequest = {},
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentLogResponse> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/log/${encodeURIComponent(logId)}`,
            ),
            method: "PATCH",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            body: serializers.UpdateAgentLogRequest.jsonOrThrow(request, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentLogResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError(
                    "Timeout exceeded when calling PATCH /agents/{id}/log/{log_id}.",
                );
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Call an Agent. The Agent will run on the Humanloop runtime and return a completed Agent Log.
     *
     * If the Agent requires a tool call that cannot be ran by Humanloop, execution will halt. To continue,
     * pass the ID of the incomplete Log and the required tool call to the /agents/continue endpoint.
     *
     * The agent will run for the maximum number of iterations, or until it encounters a stop condition,
     * according to its configuration.
     *
     * You can use query parameters `version_id`, or `environment`, to target
     * an existing version of the Agent. Otherwise the default deployed version will be chosen.
     *
     * Instead of targeting an existing version explicitly, you can instead pass in
     * Agent details in the request body. A new version is created if it does not match
     * any existing ones. This is helpful in the case where you are storing or deriving
     * your Agent details in code.
     */
    public async callStream(
        request: Humanloop.AgentsCallStreamRequest,
        requestOptions?: Agents.RequestOptions,
    ): Promise<core.Stream<Humanloop.AgentCallStreamResponse>> {
        const { versionId, environment, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (versionId != null) {
            _queryParams["version_id"] = versionId;
        }

        if (environment != null) {
            _queryParams["environment"] = environment;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)<stream.Readable>({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                "agents/call",
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: {
                ...serializers.AgentsCallStreamRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
                stream: true,
            },
            responseType: "sse",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return new core.Stream({
                stream: _response.body,
                parse: async (data) => {
                    return serializers.AgentCallStreamResponse.parseOrThrow(data, {
                        unrecognizedObjectKeys: "passthrough",
                        allowUnrecognizedUnionMembers: true,
                        allowUnrecognizedEnumValues: true,
                        skipValidation: true,
                        breadcrumbsPrefix: ["response"],
                    });
                },
                signal: requestOptions?.abortSignal,
                eventShape: {
                    type: "sse",
                    streamTerminator: "[DONE]",
                },
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling POST /agents/call.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Call an Agent. The Agent will run on the Humanloop runtime and return a completed Agent Log.
     *
     * If the Agent requires a tool call that cannot be ran by Humanloop, execution will halt. To continue,
     * pass the ID of the incomplete Log and the required tool call to the /agents/continue endpoint.
     *
     * The agent will run for the maximum number of iterations, or until it encounters a stop condition,
     * according to its configuration.
     *
     * You can use query parameters `version_id`, or `environment`, to target
     * an existing version of the Agent. Otherwise the default deployed version will be chosen.
     *
     * Instead of targeting an existing version explicitly, you can instead pass in
     * Agent details in the request body. A new version is created if it does not match
     * any existing ones. This is helpful in the case where you are storing or deriving
     * your Agent details in code.
     *
     * @param {Humanloop.AgentsCallRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.call({
     *         path: "Banking/Teller Agent",
     *         messages: [{
     *                 role: "user",
     *                 content: "I'd like to deposit $1000 to my savings account from my checking account."
     *             }]
     *     })
     */
    public async call(
        request: Humanloop.AgentsCallRequest,
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentCallResponse> {
        const { versionId, environment, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (versionId != null) {
            _queryParams["version_id"] = versionId;
        }

        if (environment != null) {
            _queryParams["environment"] = environment;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                "agents/call",
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            body: {
                ...serializers.AgentsCallRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
                stream: false,
            },
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentCallResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling POST /agents/call.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Continue an incomplete Agent call.
     *
     * This endpoint allows continuing an existing incomplete Agent call, by passing the tool call
     * requested by the Agent. The Agent will resume processing from where it left off.
     *
     * The messages in the request will be appended to the original messages in the Log. You do not
     * have to provide the previous conversation history.
     *
     * The original log must be in an incomplete state to be continued.
     */
    public async continueCallStream(
        request: Humanloop.AgentsContinueCallStreamRequest,
        requestOptions?: Agents.RequestOptions,
    ): Promise<core.Stream<Humanloop.AgentContinueCallStreamResponse>> {
        const _response = await (this._options.fetcher ?? core.fetcher)<stream.Readable>({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                "agents/continue",
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            body: {
                ...serializers.AgentsContinueCallStreamRequest.jsonOrThrow(request, {
                    unrecognizedObjectKeys: "strip",
                }),
                stream: true,
            },
            responseType: "sse",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return new core.Stream({
                stream: _response.body,
                parse: async (data) => {
                    return serializers.AgentContinueCallStreamResponse.parseOrThrow(data, {
                        unrecognizedObjectKeys: "passthrough",
                        allowUnrecognizedUnionMembers: true,
                        allowUnrecognizedEnumValues: true,
                        skipValidation: true,
                        breadcrumbsPrefix: ["response"],
                    });
                },
                signal: requestOptions?.abortSignal,
                eventShape: {
                    type: "sse",
                    streamTerminator: "[DONE]",
                },
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling POST /agents/continue.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Continue an incomplete Agent call.
     *
     * This endpoint allows continuing an existing incomplete Agent call, by passing the tool call
     * requested by the Agent. The Agent will resume processing from where it left off.
     *
     * The messages in the request will be appended to the original messages in the Log. You do not
     * have to provide the previous conversation history.
     *
     * The original log must be in an incomplete state to be continued.
     *
     * @param {Humanloop.AgentsContinueCallRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.continueCall({
     *         logId: "log_1234567890",
     *         messages: [{
     *                 role: "tool",
     *                 content: "{\"type\": \"checking\", \"balance\": 5200}",
     *                 toolCallId: "tc_1234567890"
     *             }]
     *     })
     */
    public async continueCall(
        request: Humanloop.AgentsContinueCallRequest,
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentContinueCallResponse> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                "agents/continue",
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            body: {
                ...serializers.AgentsContinueCallRequest.jsonOrThrow(request, { unrecognizedObjectKeys: "strip" }),
                stream: false,
            },
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentContinueCallResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling POST /agents/continue.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Get a list of all Agents.
     *
     * @param {Humanloop.ListAgentsGetRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.list({
     *         size: 1
     *     })
     */
    public async list(
        request: Humanloop.ListAgentsGetRequest = {},
        requestOptions?: Agents.RequestOptions,
    ): Promise<core.Page<Humanloop.AgentResponse>> {
        const list = async (request: Humanloop.ListAgentsGetRequest): Promise<Humanloop.PaginatedDataAgentResponse> => {
            const { page, size, name, userFilter, sortBy, order } = request;
            const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
            if (page != null) {
                _queryParams["page"] = page.toString();
            }
            if (size != null) {
                _queryParams["size"] = size.toString();
            }
            if (name != null) {
                _queryParams["name"] = name;
            }
            if (userFilter != null) {
                _queryParams["user_filter"] = userFilter;
            }
            if (sortBy != null) {
                _queryParams["sort_by"] = serializers.FileSortBy.jsonOrThrow(sortBy, {
                    unrecognizedObjectKeys: "strip",
                });
            }
            if (order != null) {
                _queryParams["order"] = serializers.SortOrder.jsonOrThrow(order, { unrecognizedObjectKeys: "strip" });
            }
            const _response = await (this._options.fetcher ?? core.fetcher)({
                url: urlJoin(
                    (await core.Supplier.get(this._options.baseUrl)) ??
                        (await core.Supplier.get(this._options.environment)) ??
                        environments.HumanloopEnvironment.Default,
                    "agents",
                ),
                method: "GET",
                headers: {
                    "X-Fern-Language": "JavaScript",
                    "X-Fern-SDK-Name": "humanloop",
                    "X-Fern-SDK-Version": "0.8.21-beta2",
                    "User-Agent": "humanloop/0.8.21-beta2",
                    "X-Fern-Runtime": core.RUNTIME.type,
                    "X-Fern-Runtime-Version": core.RUNTIME.version,
                    ...(await this._getCustomAuthorizationHeaders()),
                    ...requestOptions?.headers,
                },
                contentType: "application/json",
                queryParameters: _queryParams,
                requestType: "json",
                timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
                maxRetries: requestOptions?.maxRetries,
                abortSignal: requestOptions?.abortSignal,
            });
            if (_response.ok) {
                return serializers.PaginatedDataAgentResponse.parseOrThrow(_response.body, {
                    unrecognizedObjectKeys: "passthrough",
                    allowUnrecognizedUnionMembers: true,
                    allowUnrecognizedEnumValues: true,
                    skipValidation: true,
                    breadcrumbsPrefix: ["response"],
                });
            }
            if (_response.error.reason === "status-code") {
                switch (_response.error.statusCode) {
                    case 422:
                        throw new Humanloop.UnprocessableEntityError(
                            serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                                unrecognizedObjectKeys: "passthrough",
                                allowUnrecognizedUnionMembers: true,
                                allowUnrecognizedEnumValues: true,
                                skipValidation: true,
                                breadcrumbsPrefix: ["response"],
                            }),
                        );
                    default:
                        throw new errors.HumanloopError({
                            statusCode: _response.error.statusCode,
                            body: _response.error.body,
                        });
                }
            }
            switch (_response.error.reason) {
                case "non-json":
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.rawBody,
                    });
                case "timeout":
                    throw new errors.HumanloopTimeoutError("Timeout exceeded when calling GET /agents.");
                case "unknown":
                    throw new errors.HumanloopError({
                        message: _response.error.errorMessage,
                    });
            }
        };
        let _offset = request?.page != null ? request?.page : 1;
        return new core.Pageable<Humanloop.PaginatedDataAgentResponse, Humanloop.AgentResponse>({
            response: await list(request),
            hasNextPage: (response) => (response?.records ?? []).length > 0,
            getItems: (response) => response?.records ?? [],
            loadPage: (_response) => {
                _offset += 1;
                return list(core.setObjectProperty(request, "page", _offset));
            },
        });
    }

    /**
     * Create an Agent or update it with a new version if it already exists.
     *
     * Agents are identified by the `ID` or their `path`. The parameters (i.e. the template, temperature, model etc.) and
     * tools determine the versions of the Agent.
     *
     * You can provide `version_name` and `version_description` to identify and describe your versions.
     * Version names must be unique within an Agent - attempting to create a version with a name
     * that already exists will result in a 409 Conflict error.
     *
     * @param {Humanloop.AgentRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.upsert({
     *         path: "Banking/Teller Agent",
     *         provider: "anthropic",
     *         endpoint: "chat",
     *         model: "claude-3-7-sonnet-latest",
     *         reasoningEffort: 1024,
     *         template: [{
     *                 role: "system",
     *                 content: "You are a helpful digital assistant, helping users navigate our digital banking platform."
     *             }],
     *         maxIterations: 3,
     *         tools: [{
     *                 type: "inline",
     *                 jsonSchema: {
     *                     name: "stop",
     *                     description: "Call this tool when you have finished your task.",
     *                     parameters: {
     *                         "type": "object",
     *                         "properties": {
     *                             "output": {
     *                                 "type": "string",
     *                                 "description": "The final output to return to the user."
     *                             }
     *                         },
     *                         "additionalProperties": false,
     *                         "required": [
     *                             "output"
     *                         ]
     *                     },
     *                     strict: true
     *                 },
     *                 onAgentCall: "stop"
     *             }],
     *         versionName: "teller-agent-v1",
     *         versionDescription: "Initial version"
     *     })
     */
    public async upsert(
        request: Humanloop.AgentRequest,
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentResponse> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                "agents",
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            body: serializers.AgentRequest.jsonOrThrow(request, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling POST /agents.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Delete a version of the Agent.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {string} versionId - Unique identifier for the specific version of the Agent.
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.deleteAgentVersion("ag_1234567890", "agv_1234567890")
     */
    public async deleteAgentVersion(
        id: string,
        versionId: string,
        requestOptions?: Agents.RequestOptions,
    ): Promise<void> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}`,
            ),
            method: "DELETE",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return;
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError(
                    "Timeout exceeded when calling DELETE /agents/{id}/versions/{version_id}.",
                );
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Update the name or description of the Agent version.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {string} versionId - Unique identifier for the specific version of the Agent.
     * @param {Humanloop.UpdateVersionRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.patchAgentVersion("ag_1234567890", "agv_1234567890", {
     *         name: "teller-agent-v2",
     *         description: "Updated version"
     *     })
     */
    public async patchAgentVersion(
        id: string,
        versionId: string,
        request: Humanloop.UpdateVersionRequest,
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentResponse> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}`,
            ),
            method: "PATCH",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            body: serializers.UpdateVersionRequest.jsonOrThrow(request, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError(
                    "Timeout exceeded when calling PATCH /agents/{id}/versions/{version_id}.",
                );
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Retrieve the Agent with the given ID.
     *
     * By default, the deployed version of the Agent is returned. Use the query parameters
     * `version_id` or `environment` to target a specific version of the Agent.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {Humanloop.GetAgentsIdGetRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.get("ag_1234567890")
     */
    public async get(
        id: string,
        request: Humanloop.GetAgentsIdGetRequest = {},
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentResponse> {
        const { versionId, environment } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (versionId != null) {
            _queryParams["version_id"] = versionId;
        }

        if (environment != null) {
            _queryParams["environment"] = environment;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}`,
            ),
            method: "GET",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling GET /agents/{id}.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Delete the Agent with the given ID.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.delete("ag_1234567890")
     */
    public async delete(id: string, requestOptions?: Agents.RequestOptions): Promise<void> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}`,
            ),
            method: "DELETE",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return;
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling DELETE /agents/{id}.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Move the Agent to a different path or change the name.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {Humanloop.UpdateAgentRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.move("ag_1234567890", {
     *         path: "new directory/new name"
     *     })
     */
    public async move(
        id: string,
        request: Humanloop.UpdateAgentRequest = {},
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentResponse> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}`,
            ),
            method: "PATCH",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            body: serializers.UpdateAgentRequest.jsonOrThrow(request, { unrecognizedObjectKeys: "strip" }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling PATCH /agents/{id}.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Get a list of all the versions of a Agent.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {Humanloop.ListVersionsAgentsIdVersionsGetRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.listVersions("ag_1234567890")
     */
    public async listVersions(
        id: string,
        request: Humanloop.ListVersionsAgentsIdVersionsGetRequest = {},
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.ListAgents> {
        const { evaluatorAggregates } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (evaluatorAggregates != null) {
            _queryParams["evaluator_aggregates"] = evaluatorAggregates.toString();
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/versions`,
            ),
            method: "GET",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.ListAgents.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling GET /agents/{id}/versions.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Deploy Agent to an Environment.
     *
     * Set the deployed version for the specified Environment. This Agent
     * will be used for calls made to the Agent in this Environment.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {string} environmentId - Unique identifier for the Environment to deploy the Version to.
     * @param {Humanloop.SetDeploymentAgentsIdEnvironmentsEnvironmentIdPostRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.setDeployment("id", "environment_id", {
     *         versionId: "version_id"
     *     })
     */
    public async setDeployment(
        id: string,
        environmentId: string,
        request: Humanloop.SetDeploymentAgentsIdEnvironmentsEnvironmentIdPostRequest,
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentResponse> {
        const { versionId } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        _queryParams["version_id"] = versionId;
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/environments/${encodeURIComponent(environmentId)}`,
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError(
                    "Timeout exceeded when calling POST /agents/{id}/environments/{environment_id}.",
                );
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Remove deployed Agent from the Environment.
     *
     * Remove the deployed version for the specified Environment. This Agent
     * will no longer be used for calls made to the Agent in this Environment.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {string} environmentId - Unique identifier for the Environment to remove the deployment from.
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.removeDeployment("id", "environment_id")
     */
    public async removeDeployment(
        id: string,
        environmentId: string,
        requestOptions?: Agents.RequestOptions,
    ): Promise<void> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/environments/${encodeURIComponent(environmentId)}`,
            ),
            method: "DELETE",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return;
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError(
                    "Timeout exceeded when calling DELETE /agents/{id}/environments/{environment_id}.",
                );
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * List all Environments and their deployed versions for the Agent.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.listEnvironments("ag_1234567890")
     */
    public async listEnvironments(
        id: string,
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.FileEnvironmentResponse[]> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/environments`,
            ),
            method: "GET",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.agents.listEnvironments.Response.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling GET /agents/{id}/environments.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Activate and deactivate Evaluators for monitoring the Agent.
     *
     * An activated Evaluator will automatically be run on all new Logs
     * within the Agent for monitoring purposes.
     *
     * @param {string} id
     * @param {Humanloop.EvaluatorActivationDeactivationRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.updateMonitoring("ag_1234567890", {
     *         activate: [{
     *                 evaluatorVersionId: "ev_1234567890"
     *             }, {
     *                 evaluatorId: "ev_2345678901",
     *                 environmentId: "env_1234567890"
     *             }],
     *         deactivate: [{
     *                 evaluatorVersionId: "ev_0987654321"
     *             }]
     *     })
     */
    public async updateMonitoring(
        id: string,
        request: Humanloop.EvaluatorActivationDeactivationRequest,
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentResponse> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/evaluators`,
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            body: serializers.EvaluatorActivationDeactivationRequest.jsonOrThrow(request, {
                unrecognizedObjectKeys: "strip",
            }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentResponse.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling POST /agents/{id}/evaluators.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Serialize an Agent to the .agent file format.
     *
     * Useful for storing the Agent with your code in a version control system,
     * or for editing with an AI tool.
     *
     * By default, the deployed version of the Agent is returned. Use the query parameters
     * `version_id` or `environment` to target a specific version of the Agent.
     *
     * @param {string} id - Unique identifier for Agent.
     * @param {Humanloop.SerializeAgentsIdSerializeGetRequest} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.serialize("id")
     */
    public async serialize(
        id: string,
        request: Humanloop.SerializeAgentsIdSerializeGetRequest = {},
        requestOptions?: Agents.RequestOptions,
    ): Promise<string> {
        const { versionId, environment } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (versionId != null) {
            _queryParams["version_id"] = versionId;
        }

        if (environment != null) {
            _queryParams["environment"] = environment;
        }

        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                `agents/${encodeURIComponent(id)}/serialize`,
            ),
            method: "GET",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            queryParameters: _queryParams,
            requestType: "json",
            responseType: "text",
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return _response.body as string;
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling GET /agents/{id}/serialize.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    /**
     * Deserialize an Agent from the .agent file format.
     *
     * This returns a subset of the attributes required by an Agent.
     * This subset is the bit that defines the Agent version (e.g. with `model` and `temperature` etc)
     *
     * @param {Humanloop.BodyDeserializeAgentsDeserializePost} request
     * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Humanloop.UnprocessableEntityError}
     *
     * @example
     *     await client.agents.deserialize({
     *         agent: "agent"
     *     })
     */
    public async deserialize(
        request: Humanloop.BodyDeserializeAgentsDeserializePost,
        requestOptions?: Agents.RequestOptions,
    ): Promise<Humanloop.AgentKernelRequest> {
        const _response = await (this._options.fetcher ?? core.fetcher)({
            url: urlJoin(
                (await core.Supplier.get(this._options.baseUrl)) ??
                    (await core.Supplier.get(this._options.environment)) ??
                    environments.HumanloopEnvironment.Default,
                "agents/deserialize",
            ),
            method: "POST",
            headers: {
                "X-Fern-Language": "JavaScript",
                "X-Fern-SDK-Name": "humanloop",
                "X-Fern-SDK-Version": "0.8.21-beta2",
                "User-Agent": "humanloop/0.8.21-beta2",
                "X-Fern-Runtime": core.RUNTIME.type,
                "X-Fern-Runtime-Version": core.RUNTIME.version,
                ...(await this._getCustomAuthorizationHeaders()),
                ...requestOptions?.headers,
            },
            contentType: "application/json",
            requestType: "json",
            body: serializers.BodyDeserializeAgentsDeserializePost.jsonOrThrow(request, {
                unrecognizedObjectKeys: "strip",
            }),
            timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
            maxRetries: requestOptions?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return serializers.AgentKernelRequest.parseOrThrow(_response.body, {
                unrecognizedObjectKeys: "passthrough",
                allowUnrecognizedUnionMembers: true,
                allowUnrecognizedEnumValues: true,
                skipValidation: true,
                breadcrumbsPrefix: ["response"],
            });
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Humanloop.UnprocessableEntityError(
                        serializers.HttpValidationError.parseOrThrow(_response.error.body, {
                            unrecognizedObjectKeys: "passthrough",
                            allowUnrecognizedUnionMembers: true,
                            allowUnrecognizedEnumValues: true,
                            skipValidation: true,
                            breadcrumbsPrefix: ["response"],
                        }),
                    );
                default:
                    throw new errors.HumanloopError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.HumanloopError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                });
            case "timeout":
                throw new errors.HumanloopTimeoutError("Timeout exceeded when calling POST /agents/deserialize.");
            case "unknown":
                throw new errors.HumanloopError({
                    message: _response.error.errorMessage,
                });
        }
    }

    protected async _getCustomAuthorizationHeaders() {
        const apiKeyValue = (await core.Supplier.get(this._options.apiKey)) ?? process?.env["HUMANLOOP_API_KEY"];
        return { "X-API-KEY": apiKeyValue };
    }
}