@openai/agents-extensions 0.8.4 → 0.9.0

package/dist/sandbox/modal/sandbox.d.ts

@@ -0,0 +1,220 @@
+import { type ToolOutputImage } from '@openai/agents-core';
+import { Manifest, type SandboxClient, type SandboxClientCreateArgs, type SandboxClientOptions, type SandboxConcurrencyLimits, type ExposedPortEndpoint, type ExecCommandArgs, type MaterializeEntryArgs, type ReadFileArgs, type SandboxSession, type SandboxSessionState, type ViewImageArgs, type WriteStdinArgs, type WorkspaceArchiveData } from '@openai/agents-core/sandbox';
+import { RemoteSandboxEditor, type RemoteSandboxPathOptions } from '../shared';
+type ModalCloudBucketMountLike = {
+    toProto?(mountPath: string): unknown;
+};
+type ModalClientLike = {
+    apps: {
+        fromName(name: string, params?: {
+            createIfMissing?: boolean;
+            environment?: string;
+        }): Promise<ModalAppLike>;
+    };
+    images: {
+        fromRegistry(tag: string): ModalImageLike;
+        fromId?(id: string): ModalImageLike | Promise<ModalImageLike>;
+        delete?(id: string): Promise<void>;
+    };
+    sandboxes: {
+        create(app: ModalAppLike, image: ModalImageLike, params?: Record<string, unknown>): Promise<ModalSandboxLike>;
+        fromId(id: string): Promise<ModalSandboxLike>;
+    };
+    imageBuilderVersion?(version?: string): string;
+};
+type ModalAppLike = {
+    appId?: string;
+};
+type ModalImageLike = {
+    imageId?: string;
+    objectId?: string;
+    cmd?(command: string[]): ModalImageLike;
+};
+type ModalSandboxLike = {
+    sandboxId: string;
+    objectId?: string;
+    exec(command: string[], params?: Record<string, unknown>): Promise<ModalContainerProcessLike>;
+    open(path: string, mode?: string): Promise<ModalSandboxFileLike>;
+    terminate(params?: {
+        wait?: boolean;
+    }): Promise<void | number>;
+    poll(): Promise<number | null>;
+    tunnels?(timeoutMs?: number): Promise<Record<number, ModalTunnelLike>>;
+    snapshotFilesystem?(timeoutMs?: number): Promise<string | {
+        objectId?: string;
+        imageId?: string;
+        id?: string;
+    }>;
+    snapshotDirectory?(path: string): Promise<string | {
+        objectId?: string;
+        imageId?: string;
+        id?: string;
+    }>;
+    mountImage?(path: string, image?: ModalImageLike): Promise<unknown>;
+};
+type ModalTunnelLike = {
+    host?: string;
+    port?: number;
+};
+type ModalSandboxFileLike = {
+    read(): Promise<Uint8Array>;
+    write(data: Uint8Array): Promise<void>;
+    flush?(): Promise<void>;
+    close(): Promise<void>;
+};
+type ModalContainerProcessLike = {
+    stdin?: {
+        writeText?(text: string): Promise<void>;
+        close?(): Promise<void>;
+    };
+    stdout: ReadableStream<string>;
+    stderr: ReadableStream<string>;
+    wait(): Promise<number>;
+};
+type ModalCloudBucketMountsProvider = () => Promise<Record<string, ModalCloudBucketMountLike> | undefined>;
+export type ModalWorkspacePersistence = 'tar' | 'snapshot_filesystem' | 'snapshot_directory';
+export type ModalImageSelectorKind = 'image' | 'id' | 'tag';
+export declare class ModalImageSelector {
+    readonly kind: ModalImageSelectorKind;
+    readonly value: ModalImageLike | string;
+    private constructor();
+    static fromImage(image: ModalImageLike): ModalImageSelector;
+    static fromId(imageId: string): ModalImageSelector;
+    static fromTag(imageTag: string): ModalImageSelector;
+}
+export type ModalSandboxSelectorKind = 'sandbox' | 'id';
+export declare class ModalSandboxSelector {
+    readonly kind: ModalSandboxSelectorKind;
+    readonly value: ModalSandboxLike | string;
+    private constructor();
+    static fromSandbox(sandbox: ModalSandboxLike): ModalSandboxSelector;
+    static fromId(sandboxId: string): ModalSandboxSelector;
+}
+export interface ModalSandboxClientOptions extends SandboxClientOptions {
+    appName: string;
+    image?: ModalImageSelector;
+    sandbox?: ModalSandboxSelector;
+    imageTag?: string;
+    sandboxCreateTimeoutS?: number;
+    workspacePersistence?: ModalWorkspacePersistence;
+    snapshotFilesystemTimeoutMs?: number;
+    snapshotFilesystemRestoreTimeoutMs?: number;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    idleTimeoutMs?: number;
+    gpu?: string;
+    exposedPorts?: number[];
+    environment?: string;
+    endpoint?: string;
+    tokenId?: string;
+    tokenSecret?: string;
+    imageBuilderVersion?: string;
+    nativeCloudBucketSecretName?: string;
+    useSleepCmd?: boolean;
+}
+export interface ModalSandboxSessionState extends SandboxSessionState {
+    sandboxId?: string;
+    ownsSandbox?: boolean;
+    appName: string;
+    imageId?: string;
+    imageTag: string;
+    sandboxCreateTimeoutS?: number;
+    workspacePersistence: ModalWorkspacePersistence;
+    snapshotFilesystemTimeoutMs?: number;
+    snapshotFilesystemRestoreTimeoutMs?: number;
+    environment: Record<string, string>;
+    timeoutMs?: number;
+    idleTimeoutMs?: number;
+    gpu?: string;
+    configuredExposedPorts?: number[];
+    modalEnvironment?: string;
+    endpoint?: string;
+    imageBuilderVersion?: string;
+    nativeCloudBucketSecretName?: string;
+    useSleepCmd: boolean;
+}
+export declare class ModalSandboxSession implements SandboxSession<ModalSandboxSessionState> {
+    readonly state: ModalSandboxSessionState;
+    private readonly modal;
+    private readonly app;
+    private readonly cloudBucketMountsProvider?;
+    private cloudBucketMounts?;
+    private cloudBucketMountsResolved;
+    private sandbox;
+    private ownsSandbox;
+    private closed;
+    private closePromise?;
+    private readonly activeProcesses;
+    private readonly remotePathResolver;
+    private readonly concurrencyLimits?;
+    private nextProcessId;
+    constructor(args: {
+        state: ModalSandboxSessionState;
+        modal: ModalClientLike;
+        app: ModalAppLike;
+        sandbox: ModalSandboxLike;
+        ownsSandbox?: boolean;
+        cloudBucketMounts?: Record<string, ModalCloudBucketMountLike>;
+        cloudBucketMountsProvider?: ModalCloudBucketMountsProvider;
+        concurrencyLimits?: SandboxConcurrencyLimits;
+    });
+    createEditor(runAs?: string): RemoteSandboxEditor;
+    supportsPty(): boolean;
+    execCommand(args: ExecCommandArgs): Promise<string>;
+    writeStdin(args: WriteStdinArgs): Promise<string>;
+    viewImage(args: ViewImageArgs): Promise<ToolOutputImage>;
+    readFile(args: ReadFileArgs): Promise<Uint8Array>;
+    pathExists(path: string, runAs?: string): Promise<boolean>;
+    running(): Promise<boolean>;
+    resolveExposedPort(port: number): Promise<ExposedPortEndpoint>;
+    materializeEntry(args: MaterializeEntryArgs): Promise<void>;
+    applyManifest(manifest: Manifest, runAs?: string): Promise<void>;
+    persistWorkspace(): Promise<Uint8Array>;
+    hydrateWorkspace(data: WorkspaceArchiveData): Promise<void>;
+    private persistSnapshotFilesystem;
+    private persistSnapshotDirectory;
+    private nativeSnapshotRequiresTarFallback;
+    private assertExpectedSnapshotPersistence;
+    private restoreSnapshotFilesystem;
+    private restoreSnapshotDirectory;
+    private deleteSnapshotDirectoryImage;
+    private modalImageFromId;
+    private sandboxCreateParams;
+    private resolveCloudBucketMounts;
+    close(): Promise<void>;
+    private closeOnce;
+    private resetActiveProcesses;
+    private manifestMaterializationOptions;
+    private invalidateCloudBucketMounts;
+    shutdown(): Promise<void>;
+    delete(): Promise<void>;
+    private registerActiveProcess;
+    private deleteActiveProcess;
+    resolveAbsolutePath(path?: string): string;
+    resolveRemotePath(path?: string, options?: RemoteSandboxPathOptions): Promise<string>;
+    resolveWorkdir(path?: string): string;
+    ensureDirectory(path: string): Promise<void>;
+    writeSandboxFile(path: string, content: string | Uint8Array): Promise<void>;
+    readSandboxFile(path: string): Promise<Uint8Array>;
+    removeSandboxPath(path: string): Promise<void>;
+    private runAsCommandRunner;
+    private writer;
+    private archiveIo;
+    private runDirectCommand;
+}
+/**
+ * @see {@link https://modal.com/docs/guide/sandboxes | Sandboxes guide}.
+ * @see {@link https://modal.com/docs/guide/sdk-javascript-go | JavaScript and Go SDK guide}.
+ * @see {@link https://modal.com/docs/reference/modal.Sandbox | Sandbox reference}.
+ */
+export declare class ModalSandboxClient implements SandboxClient<ModalSandboxClientOptions, ModalSandboxSessionState> {
+    readonly backendId = "modal";
+    private readonly options;
+    constructor(options?: Partial<ModalSandboxClientOptions>);
+    create(args?: SandboxClientCreateArgs | Manifest, manifestOptions?: SandboxClientOptions): Promise<ModalSandboxSession>;
+    serializeSessionState(state: ModalSandboxSessionState): Promise<Record<string, unknown>>;
+    canPersistOwnedSessionState(): boolean;
+    deserializeSessionState(state: Record<string, unknown>): Promise<ModalSandboxSessionState>;
+    resume(state: ModalSandboxSessionState): Promise<ModalSandboxSession>;
+}
+export {};