langsmith 0.7.11 → 0.7.13

package/dist/_openapi_client/resources/runs/runs.js

@@ -0,0 +1,78 @@
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { APIResource } from '../../core/resource.js';
+import * as RulesAPI from './rules.js';
+import { Rules } from './rules.js';
+import { ItemsCursorPostPagination, } from '../../core/pagination.js';
+import { buildHeaders } from '../../internal/headers.js';
+import { path } from '../../internal/utils/path.js';
+export class Runs extends APIResource {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "rules", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new RulesAPI.Rules(this._client)
+        });
+        Object.defineProperty(this, "retrieve", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: this.retrieveV2
+        });
+        Object.defineProperty(this, "query", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: this.queryV2
+        });
+    }
+    /**
+     * **Alpha:** The request and response contract may change; Returns a paginated
+     * list of runs for the given projects within min/max start_time. Supports filters,
+     * cursor pagination, and `selects` to select fields to return.
+     *
+     * @example
+     * ```ts
+     * // Automatically fetches more pages as needed.
+     * for await (const queryRunResponse of client.runs.queryV2()) {
+     *   // ...
+     * }
+     * ```
+     */
+    queryV2(params, options) {
+        const { Accept, ...body } = params;
+        return this._client.getAPIList('/v2/runs/query', (ItemsCursorPostPagination), {
+            body,
+            method: 'post',
+            ...options,
+            headers: buildHeaders([{ ...(Accept != null ? { Accept: Accept } : undefined) }, options?.headers]),
+        });
+    }
+    /**
+     * **Alpha:** The request and response contract may change; Returns one run by ID
+     * for the given session and start_time. Use the `selects` query parameter
+     * (repeatable) to select fields to return.
+     *
+     * @example
+     * ```ts
+     * const queryRunResponse = await client.runs.retrieveV2(
+     *   '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+     *   {
+     *     project_id: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+     *     start_time: '2019-12-27T18:11:19.117Z',
+     *   },
+     * );
+     * ```
+     */
+    retrieveV2(runID, params, options) {
+        const { Accept, ...query } = params;
+        return this._client.get(path `/v2/runs/${runID}`, {
+            query,
+            ...options,
+            headers: buildHeaders([{ ...(Accept != null ? { Accept: Accept } : undefined) }, options?.headers]),
+        });
+    }
+}
+Runs.Rules = Rules;

package/dist/_openapi_client/resources/runs.cjs

@@ -0,0 +1,19 @@
+"use strict";
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./runs/index.cjs"), exports);

package/dist/_openapi_client/resources/runs.d.ts

@@ -0,0 +1 @@
+export * from './runs/index.js';

package/dist/_openapi_client/resources/runs.js

@@ -0,0 +1,3 @@
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+export * from './runs/index.js';

package/dist/_openapi_client/resources/sandboxes/boxes.cjs

@@ -0,0 +1,86 @@
+"use strict";
+// @ts-nocheck
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Boxes = void 0;
+const resource_js_1 = require("../../core/resource.cjs");
+const headers_js_1 = require("../../internal/headers.cjs");
+const path_js_1 = require("../../internal/utils/path.cjs");
+class Boxes extends resource_js_1.APIResource {
+    /**
+     * Create a new sandbox from a snapshot. Provide at most one of `snapshot_id` or
+     * `snapshot_name`; if neither is provided, the server uses the default static
+     * blueprint.
+     */
+    create(body, options) {
+        return this._client.post('/v2/sandboxes/boxes', { body, ...options });
+    }
+    /**
+     * Retrieve a sandbox by name. Stale provisioning sandboxes are auto-failed.
+     */
+    retrieve(name, options) {
+        return this._client.get((0, path_js_1.path) `/v2/sandboxes/boxes/${name}`, options);
+    }
+    /**
+     * Update a sandbox's display name. The name must be unique within the tenant.
+     */
+    update(name, body, options) {
+        return this._client.patch((0, path_js_1.path) `/v2/sandboxes/boxes/${name}`, { body, ...options });
+    }
+    /**
+     * List sandboxes for the authenticated tenant, with optional filtering, sorting,
+     * and pagination.
+     */
+    list(query = {}, options) {
+        return this._client.get('/v2/sandboxes/boxes', { query, ...options });
+    }
+    /**
+     * Delete a sandbox by name or UUID. Tears down the sandbox runtime and removes the
+     * DB record.
+     */
+    delete(name, options) {
+        return this._client.delete((0, path_js_1.path) `/v2/sandboxes/boxes/${name}`, {
+            ...options,
+            headers: (0, headers_js_1.buildHeaders)([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+    /**
+     * Create a snapshot by capturing the current state of a sandbox or promoting an
+     * existing checkpoint.
+     */
+    createSnapshot(name, body, options) {
+        return this._client.post((0, path_js_1.path) `/v2/sandboxes/boxes/${name}/snapshot`, { body, ...options });
+    }
+    /**
+     * Create a short-lived JWT for accessing an HTTP service running on a specific
+     * port inside a sandbox. Returns a browser_url (sets auth cookie via redirect), a
+     * service_url (for use with the X-Langsmith-Sandbox-Service-Token header), the raw
+     * token, and its expiry.
+     */
+    generateServiceURL(name, body, options) {
+        return this._client.post((0, path_js_1.path) `/v2/sandboxes/boxes/${name}/service-url`, { body, ...options });
+    }
+    /**
+     * Retrieve the lightweight status of a sandbox for polling.
+     */
+    getStatus(name, options) {
+        return this._client.get((0, path_js_1.path) `/v2/sandboxes/boxes/${name}/status`, options);
+    }
+    /**
+     * Start a stopped or failed sandbox. This endpoint is not idempotent.
+     */
+    start(name, options) {
+        return this._client.post((0, path_js_1.path) `/v2/sandboxes/boxes/${name}/start`, options);
+    }
+    /**
+     * Stop a ready sandbox. This endpoint is not idempotent; the filesystem is
+     * preserved for later restart.
+     */
+    stop(name, options) {
+        return this._client.post((0, path_js_1.path) `/v2/sandboxes/boxes/${name}/stop`, {
+            ...options,
+            headers: (0, headers_js_1.buildHeaders)([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+}
+exports.Boxes = Boxes;

package/dist/_openapi_client/resources/sandboxes/boxes.d.ts

@@ -0,0 +1,458 @@
+import { APIResource } from '../../core/resource.js';
+import * as SandboxesAPI from './sandboxes.js';
+import { APIPromise } from '../../core/api-promise.js';
+import { RequestOptions } from '../../internal/request-options.js';
+export declare class Boxes extends APIResource {
+    /**
+     * Create a new sandbox from a snapshot. Provide at most one of `snapshot_id` or
+     * `snapshot_name`; if neither is provided, the server uses the default static
+     * blueprint.
+     */
+    create(body: BoxCreateParams, options?: RequestOptions): APIPromise<SandboxesAPI.SandboxResponse>;
+    /**
+     * Retrieve a sandbox by name. Stale provisioning sandboxes are auto-failed.
+     */
+    retrieve(name: string, options?: RequestOptions): APIPromise<SandboxesAPI.SandboxResponse>;
+    /**
+     * Update a sandbox's display name. The name must be unique within the tenant.
+     */
+    update(name: string, body: BoxUpdateParams, options?: RequestOptions): APIPromise<SandboxesAPI.SandboxResponse>;
+    /**
+     * List sandboxes for the authenticated tenant, with optional filtering, sorting,
+     * and pagination.
+     */
+    list(query?: BoxListParams | null | undefined, options?: RequestOptions): APIPromise<SandboxesAPI.SandboxListResponse>;
+    /**
+     * Delete a sandbox by name or UUID. Tears down the sandbox runtime and removes the
+     * DB record.
+     */
+    delete(name: string, options?: RequestOptions): APIPromise<void>;
+    /**
+     * Create a snapshot by capturing the current state of a sandbox or promoting an
+     * existing checkpoint.
+     */
+    createSnapshot(name: string, body: BoxCreateSnapshotParams, options?: RequestOptions): APIPromise<SandboxesAPI.SnapshotResponse>;
+    /**
+     * Create a short-lived JWT for accessing an HTTP service running on a specific
+     * port inside a sandbox. Returns a browser_url (sets auth cookie via redirect), a
+     * service_url (for use with the X-Langsmith-Sandbox-Service-Token header), the raw
+     * token, and its expiry.
+     */
+    generateServiceURL(name: string, body: BoxGenerateServiceURLParams, options?: RequestOptions): APIPromise<SandboxesAPI.ServiceURLResponse>;
+    /**
+     * Retrieve the lightweight status of a sandbox for polling.
+     */
+    getStatus(name: string, options?: RequestOptions): APIPromise<SandboxesAPI.SandboxStatusResponse>;
+    /**
+     * Start a stopped or failed sandbox. This endpoint is not idempotent.
+     */
+    start(name: string, options?: RequestOptions): APIPromise<SandboxesAPI.SandboxResponse>;
+    /**
+     * Stop a ready sandbox. This endpoint is not idempotent; the filesystem is
+     * preserved for later restart.
+     */
+    stop(name: string, options?: RequestOptions): APIPromise<void>;
+}
+export interface BoxCreateParams {
+    delete_after_stop_seconds?: number;
+    env_vars?: {
+        [key: string]: string;
+    };
+    fs_capacity_bytes?: number;
+    idle_ttl_seconds?: number;
+    mem_bytes?: number;
+    mount_config?: BoxCreateParams.MountConfig;
+    name?: string;
+    proxy_config?: BoxCreateParams.ProxyConfig;
+    /**
+     * RestoreMemory selects how the sandbox handles a snapshot's captured memory:
+     *
+     * nil → if-present: resume from memory when the snapshot has it, else cold-boot
+     * (default). true → always: resume from memory; rejected if the snapshot has none.
+     * false → never: always cold-boot.
+     *
+     * Applies to this request only.
+     */
+    restore_memory?: boolean;
+    snapshot_id?: string;
+    snapshot_name?: string;
+    tag_value_ids?: Array<string>;
+    vcpus?: number;
+}
+export declare namespace BoxCreateParams {
+    interface MountConfig {
+        auth?: MountConfig.Auth;
+        mounts?: Array<MountConfig.SandboxapiS3BucketMountSpec | MountConfig.SandboxapiGcsBucketMountSpec | MountConfig.SandboxapiGitRepoMountSpec>;
+    }
+    namespace MountConfig {
+        interface Auth {
+            aws?: Auth.Aws;
+            gcp?: Auth.Gcp;
+        }
+        namespace Auth {
+            interface Aws {
+                access_key_id: Aws.AccessKeyID;
+                secret_access_key: Aws.SecretAccessKey;
+            }
+            namespace Aws {
+                interface AccessKeyID {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+                interface SecretAccessKey {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+            interface Gcp {
+                service_account_json: Gcp.ServiceAccountJson;
+            }
+            namespace Gcp {
+                interface ServiceAccountJson {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+        }
+        interface SandboxapiS3BucketMountSpec {
+            id: string;
+            mount_path: string;
+            s3: SandboxapiS3BucketMountSpec.S3;
+            type: 's3' | 'gcs' | 'git';
+            cache?: SandboxapiS3BucketMountSpec.Cache;
+            gcs?: SandboxapiS3BucketMountSpec.Gcs;
+            git?: SandboxapiS3BucketMountSpec.Git;
+            read_only?: boolean;
+        }
+        namespace SandboxapiS3BucketMountSpec {
+            interface S3 {
+                bucket: string;
+                region: string;
+                endpoint_url?: string;
+                path_style?: boolean;
+                prefix?: string;
+            }
+            interface Cache {
+                max_size_bytes?: number;
+                writeback_seconds?: number;
+            }
+            interface Gcs {
+                bucket: string;
+                prefix?: string;
+            }
+            interface Git {
+                remote_url: string;
+                ref?: Git.Ref;
+                refresh_interval_seconds?: number;
+            }
+            namespace Git {
+                interface Ref {
+                    name: string;
+                    type: 'branch' | 'tag';
+                }
+            }
+        }
+        interface SandboxapiGcsBucketMountSpec {
+            id: string;
+            gcs: SandboxapiGcsBucketMountSpec.Gcs;
+            mount_path: string;
+            type: 's3' | 'gcs' | 'git';
+            cache?: SandboxapiGcsBucketMountSpec.Cache;
+            git?: SandboxapiGcsBucketMountSpec.Git;
+            read_only?: boolean;
+            s3?: SandboxapiGcsBucketMountSpec.S3;
+        }
+        namespace SandboxapiGcsBucketMountSpec {
+            interface Gcs {
+                bucket: string;
+                prefix?: string;
+            }
+            interface Cache {
+                max_size_bytes?: number;
+                writeback_seconds?: number;
+            }
+            interface Git {
+                remote_url: string;
+                ref?: Git.Ref;
+                refresh_interval_seconds?: number;
+            }
+            namespace Git {
+                interface Ref {
+                    name: string;
+                    type: 'branch' | 'tag';
+                }
+            }
+            interface S3 {
+                bucket: string;
+                region: string;
+                endpoint_url?: string;
+                path_style?: boolean;
+                prefix?: string;
+            }
+        }
+        interface SandboxapiGitRepoMountSpec {
+            id: string;
+            git: SandboxapiGitRepoMountSpec.Git;
+            mount_path: string;
+            type: 's3' | 'gcs' | 'git';
+            cache?: SandboxapiGitRepoMountSpec.Cache;
+            gcs?: SandboxapiGitRepoMountSpec.Gcs;
+            read_only?: boolean;
+            s3?: SandboxapiGitRepoMountSpec.S3;
+        }
+        namespace SandboxapiGitRepoMountSpec {
+            interface Git {
+                remote_url: string;
+                ref?: Git.Ref;
+                refresh_interval_seconds?: number;
+            }
+            namespace Git {
+                interface Ref {
+                    name: string;
+                    type: 'branch' | 'tag';
+                }
+            }
+            interface Cache {
+                max_size_bytes?: number;
+                writeback_seconds?: number;
+            }
+            interface Gcs {
+                bucket: string;
+                prefix?: string;
+            }
+            interface S3 {
+                bucket: string;
+                region: string;
+                endpoint_url?: string;
+                path_style?: boolean;
+                prefix?: string;
+            }
+        }
+    }
+    interface ProxyConfig {
+        access_control?: ProxyConfig.AccessControl;
+        callbacks?: Array<ProxyConfig.Callback>;
+        no_proxy?: Array<string>;
+        rules?: Array<ProxyConfig.Rule>;
+    }
+    namespace ProxyConfig {
+        interface AccessControl {
+            allow_list?: Array<string>;
+            deny_list?: Array<string>;
+        }
+        interface Callback {
+            match_hosts: Array<string>;
+            ttl_seconds: number;
+            url: string;
+            full_request?: boolean;
+            request_headers?: Array<Callback.RequestHeader>;
+        }
+        namespace Callback {
+            interface RequestHeader {
+                name: string;
+                type: 'plaintext' | 'opaque' | 'workspace_secret';
+                is_set?: boolean;
+                value?: string;
+            }
+        }
+        interface Rule {
+            name: string;
+            aws?: Rule.Aws;
+            enabled?: boolean;
+            gcp?: Rule.Gcp;
+            headers?: Array<Rule.Header>;
+            /**
+             * MatchHosts is only accepted for header injection rules. Provider auth rules use
+             * built-in host matching.
+             */
+            match_hosts?: Array<string>;
+            match_paths?: Array<string>;
+            type?: string;
+        }
+        namespace Rule {
+            interface Aws {
+                access_key_id: Aws.AccessKeyID;
+                secret_access_key: Aws.SecretAccessKey;
+            }
+            namespace Aws {
+                interface AccessKeyID {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+                interface SecretAccessKey {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+            interface Gcp {
+                scopes: Array<string>;
+                service_account_json: Gcp.ServiceAccountJson;
+            }
+            namespace Gcp {
+                interface ServiceAccountJson {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+            interface Header {
+                name: string;
+                type: 'plaintext' | 'opaque' | 'workspace_secret';
+                is_set?: boolean;
+                value?: string;
+            }
+        }
+    }
+}
+export interface BoxUpdateParams {
+    delete_after_stop_seconds?: number;
+    fs_capacity_bytes?: number;
+    idle_ttl_seconds?: number;
+    mem_bytes?: number;
+    name?: string;
+    proxy_config?: BoxUpdateParams.ProxyConfig;
+    tag_value_ids?: Array<string>;
+    vcpus?: number;
+}
+export declare namespace BoxUpdateParams {
+    interface ProxyConfig {
+        access_control?: ProxyConfig.AccessControl;
+        callbacks?: Array<ProxyConfig.Callback>;
+        no_proxy?: Array<string>;
+        rules?: Array<ProxyConfig.Rule>;
+    }
+    namespace ProxyConfig {
+        interface AccessControl {
+            allow_list?: Array<string>;
+            deny_list?: Array<string>;
+        }
+        interface Callback {
+            match_hosts: Array<string>;
+            ttl_seconds: number;
+            url: string;
+            full_request?: boolean;
+            request_headers?: Array<Callback.RequestHeader>;
+        }
+        namespace Callback {
+            interface RequestHeader {
+                name: string;
+                type: 'plaintext' | 'opaque' | 'workspace_secret';
+                is_set?: boolean;
+                value?: string;
+            }
+        }
+        interface Rule {
+            name: string;
+            aws?: Rule.Aws;
+            enabled?: boolean;
+            gcp?: Rule.Gcp;
+            headers?: Array<Rule.Header>;
+            /**
+             * MatchHosts is only accepted for header injection rules. Provider auth rules use
+             * built-in host matching.
+             */
+            match_hosts?: Array<string>;
+            match_paths?: Array<string>;
+            type?: string;
+        }
+        namespace Rule {
+            interface Aws {
+                access_key_id: Aws.AccessKeyID;
+                secret_access_key: Aws.SecretAccessKey;
+            }
+            namespace Aws {
+                interface AccessKeyID {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+                interface SecretAccessKey {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+            interface Gcp {
+                scopes: Array<string>;
+                service_account_json: Gcp.ServiceAccountJson;
+            }
+            namespace Gcp {
+                interface ServiceAccountJson {
+                    type: 'plaintext' | 'opaque' | 'workspace_secret';
+                    is_set?: boolean;
+                    value?: string;
+                }
+            }
+            interface Header {
+                name: string;
+                type: 'plaintext' | 'opaque' | 'workspace_secret';
+                is_set?: boolean;
+                value?: string;
+            }
+        }
+    }
+}
+export interface BoxListParams {
+    /**
+     * Filter by creator identity. Only 'me' is supported.
+     */
+    created_by?: string;
+    /**
+     * Maximum number of results
+     */
+    limit?: number;
+    /**
+     * Filter by name substring
+     */
+    name_contains?: string;
+    /**
+     * Pagination offset
+     */
+    offset?: number;
+    /**
+     * Sort column (name, status, created_at)
+     */
+    sort_by?: string;
+    /**
+     * Sort direction (asc, desc)
+     */
+    sort_direction?: string;
+    /**
+     * Filter by status (provisioning, ready, failed, stopped, deleting)
+     */
+    status?: string;
+}
+export interface BoxCreateSnapshotParams {
+    name: string;
+    /**
+     * if omitted, creates a fresh checkpoint from the running VM
+     */
+    checkpoint?: string;
+    /**
+     * sandbox-local Docker image to export
+     */
+    docker_image?: string;
+    /**
+     * required for Docker image export unless the sandbox has a capacity
+     */
+    fs_capacity_bytes?: number;
+    /**
+     * IncludeMemory, when true, captures a full VM memory snapshot alongside the
+     * filesystem clone. Only honored when the sandbox is running AND Checkpoint is
+     * omitted (i.e. a fresh in-VM checkpoint is requested). Defaults to false to keep
+     * snapshots small unless memory restore is explicitly desired.
+     */
+    include_memory?: boolean;
+}
+export interface BoxGenerateServiceURLParams {
+    expires_in_seconds?: number;
+    port?: number;
+}
+export declare namespace Boxes {
+    export { type BoxCreateParams as BoxCreateParams, type BoxUpdateParams as BoxUpdateParams, type BoxListParams as BoxListParams, type BoxCreateSnapshotParams as BoxCreateSnapshotParams, type BoxGenerateServiceURLParams as BoxGenerateServiceURLParams, };
+}