@openai/agents-extensions 0.8.4 → 0.9.0

package/dist/sandbox/blaxel/sandbox.d.ts

@@ -0,0 +1,155 @@
+import { Manifest, type SandboxClient, type SandboxClientCreateArgs, type SandboxClientOptions, type SandboxConcurrencyLimits, type ExposedPortEndpoint, type ExecCommandArgs, type Mount, type SandboxSessionState, type TypedMount, type WriteStdinArgs } from '@openai/agents-core/sandbox';
+import { RemoteSandboxSessionBase, type RemoteSandboxCommandOptions, type RemoteSandboxCommandResult } from '../shared';
+import { type BlaxelDriveApi } from './mounts';
+export declare const DEFAULT_BLAXEL_WORKSPACE_ROOT = "/workspace";
+type BlaxelCreateInternalOptions = {
+    allowExistingNamedSandbox?: boolean;
+};
+type BlaxelSandboxLike = {
+    name?: string;
+    metadata?: {
+        name?: string;
+        createdAt?: string;
+        workspace?: string;
+        createdBy?: string;
+    };
+    status?: string;
+    url?: string;
+    sandbox?: {
+        metadata?: {
+            url?: string;
+        };
+    };
+    process: {
+        exec(params: Record<string, unknown>): Promise<BlaxelProcessResult>;
+    };
+    fs: {
+        mkdir(path: string): Promise<void>;
+        write(path: string, content: string): Promise<void>;
+        writeBinary(path: string, content: Uint8Array): Promise<void>;
+        read(path: string): Promise<string>;
+        readBinary(path: string): Promise<Blob | Uint8Array | ArrayBuffer>;
+        rm(path: string, recursive?: boolean): Promise<void>;
+    };
+    previews?: BlaxelPreviewApi;
+    drives?: BlaxelDriveApi;
+    delete(): Promise<void>;
+};
+type BlaxelPreviewApi = {
+    createIfNotExists(params: Record<string, unknown>): Promise<unknown>;
+};
+type BlaxelProcessResult = {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number | null;
+};
+export interface BlaxelSandboxTimeouts {
+    execTimeoutMs?: number;
+    createTimeoutMs?: number;
+    cleanupTimeoutMs?: number;
+    fileUploadTimeoutMs?: number;
+    fileDownloadTimeoutMs?: number;
+    workspaceTarTimeoutMs?: number;
+    fastOperationTimeoutMs?: number;
+}
+export interface BlaxelSandboxClientOptions extends SandboxClientOptions {
+    image?: string;
+    memory?: number;
+    region?: string;
+    ports?: Array<Record<string, unknown>>;
+    exposedPortPublic?: boolean;
+    exposedPortUrlTtlS?: number;
+    timeoutMs?: number;
+    createTimeoutMs?: number;
+    timeouts?: BlaxelSandboxTimeouts;
+    apiKey?: string;
+    env?: Record<string, string>;
+    labels?: Record<string, string>;
+    ttl?: string;
+    name?: string;
+    pauseOnExit?: boolean;
+}
+export interface BlaxelSandboxSessionState extends SandboxSessionState {
+    sandboxName: string;
+    sandboxIdentity?: string;
+    mountArtifactScope?: string;
+    image?: string;
+    memory?: number;
+    region?: string;
+    ports?: Array<Record<string, unknown>>;
+    exposedPortPublic?: boolean;
+    exposedPortUrlTtlS?: number;
+    timeoutMs?: number;
+    createTimeoutMs?: number;
+    timeouts?: BlaxelSandboxTimeouts;
+    sandboxUrl?: string;
+    labels?: Record<string, string>;
+    ttl?: string;
+    pauseOnExit: boolean;
+    ownsSandbox: boolean;
+    environment: Record<string, string>;
+}
+export declare class BlaxelSandboxSession extends RemoteSandboxSessionBase<BlaxelSandboxSessionState> {
+    private readonly sandbox;
+    private readonly apiKey?;
+    private ownsSandbox;
+    private closed;
+    private readonly ptyProcesses;
+    private readonly activeFuseMountPaths;
+    private readonly activeDriveMountPaths;
+    constructor(args: {
+        state: BlaxelSandboxSessionState;
+        sandbox: BlaxelSandboxLike;
+        apiKey?: string;
+        ownsSandbox?: boolean;
+        concurrencyLimits?: SandboxConcurrencyLimits;
+    });
+    supportsPty(): boolean;
+    writeStdin(args: WriteStdinArgs): Promise<string>;
+    protected execPtyCommand(args: ExecCommandArgs): Promise<string>;
+    protected allowOnDemandExposedPorts(): boolean;
+    protected useCachedExposedPortEndpoint(_port: number): boolean;
+    protected exposedPortSource(): string;
+    protected resolveRemoteExposedPort(requestedPort: number): Promise<ExposedPortEndpoint>;
+    prepareWorkspaceRoot(): Promise<void>;
+    close(): Promise<void>;
+    shutdown(): Promise<void>;
+    delete(): Promise<void>;
+    rehydrateActiveMountPathsFromManifest(): Promise<void>;
+    protected manifestMetadataSupport(): import("../shared").SandboxManifestMetadataSupport;
+    protected manifestMaterializationOptions(): {
+        materializeMount: (absolutePath: string, entry: Mount | TypedMount) => Promise<void>;
+    };
+    protected assertExecRunAs(_runAs?: string): void;
+    protected assertFilesystemRunAs(_runAs?: string): void;
+    private materializeMountEntry;
+    private unmountActiveMounts;
+    private mountCommandRunner;
+    private writeMountSecretFile;
+    protected runRemoteCommand(command: string, options: RemoteSandboxCommandOptions): Promise<RemoteSandboxCommandResult>;
+    protected mkdirRemote(path: string): Promise<void>;
+    protected readRemoteText(path: string): Promise<string>;
+    protected readRemoteFile(path: string): Promise<Uint8Array>;
+    protected writeRemoteFile(path: string, content: string | Uint8Array): Promise<void>;
+    private writeRemoteTempFile;
+    protected deleteRemotePath(path: string): Promise<void>;
+    private ensureMountArtifactScope;
+    private timeoutForCommand;
+}
+/**
+ * @see {@link https://docs.blaxel.ai/Sandboxes/Overview | Sandboxes overview}.
+ * @see {@link https://docs.blaxel.ai/Sandboxes/Filesystem | Filesystem operations}.
+ * @see {@link https://docs.blaxel.ai/Sandboxes/Sessions | Client-side sessions}.
+ */
+export declare class BlaxelSandboxClient implements SandboxClient<BlaxelSandboxClientOptions, BlaxelSandboxSessionState> {
+    readonly backendId = "blaxel";
+    private readonly options;
+    constructor(options?: BlaxelSandboxClientOptions);
+    create(args?: SandboxClientCreateArgs<BlaxelSandboxClientOptions> | Manifest, manifestOptions?: BlaxelSandboxClientOptions, internalOptions?: BlaxelCreateInternalOptions): Promise<BlaxelSandboxSession>;
+    serializeSessionState(state: BlaxelSandboxSessionState): Promise<Record<string, unknown>>;
+    canPersistOwnedSessionState(state: BlaxelSandboxSessionState): boolean;
+    deserializeSessionState(state: Record<string, unknown>): Promise<BlaxelSandboxSessionState>;
+    resume(state: BlaxelSandboxSessionState): Promise<BlaxelSandboxSession>;
+    private recreateFromState;
+}
+export {};