modal 0.10.2-dev.5 → 0.10.2-dev.7

package/dist/index.js

@@ -47974,6 +47974,108 @@ var SecretDeleteRequest = {
     return message;
   }
 };
+function createBaseSecretGetInfoRequest() {
+  return { secretId: "" };
+}
+var SecretGetInfoRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.secretId !== "") {
+      writer.uint32(10).string(message.secretId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSecretGetInfoRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.secretId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { secretId: isSet5(object.secretId) ? globalThis.String(object.secretId) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.secretId !== "") {
+      obj.secretId = message.secretId;
+    }
+    return obj;
+  },
+  create(base) {
+    return SecretGetInfoRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSecretGetInfoRequest();
+    message.secretId = object.secretId ?? "";
+    return message;
+  }
+};
+function createBaseSecretGetInfoResponse() {
+  return { metadata: void 0 };
+}
+var SecretGetInfoResponse = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.metadata !== void 0) {
+      SecretMetadata.encode(message.metadata, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSecretGetInfoResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.metadata = SecretMetadata.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { metadata: isSet5(object.metadata) ? SecretMetadata.fromJSON(object.metadata) : void 0 };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.metadata !== void 0) {
+      obj.metadata = SecretMetadata.toJSON(message.metadata);
+    }
+    return obj;
+  },
+  create(base) {
+    return SecretGetInfoResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSecretGetInfoResponse();
+    message.metadata = object.metadata !== void 0 && object.metadata !== null ? SecretMetadata.fromPartial(object.metadata) : void 0;
+    return message;
+  }
+};
 function createBaseSecretGetOrCreateRequest() {
   return { deploymentName: "", environmentName: "", objectCreationType: 0, envDict: {}, appId: "", requiredKeys: [] };
 }
@@ -48520,7 +48622,7 @@ var SecretListResponse = {
   }
 };
 function createBaseSecretMetadata() {
-  return { name: "", creationInfo: void 0, keys: [] };
+  return { name: "", creationInfo: void 0, keys: [], environmentName: "" };
 }
 var SecretMetadata = {
   encode(message, writer = new BinaryWriter()) {
@@ -48533,6 +48635,9 @@ var SecretMetadata = {
     for (const v of message.keys) {
       writer.uint32(26).string(v);
     }
+    if (message.environmentName !== "") {
+      writer.uint32(34).string(message.environmentName);
+    }
     return writer;
   },
   decode(input, length) {
@@ -48563,6 +48668,13 @@ var SecretMetadata = {
           message.keys.push(reader.string());
           continue;
         }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.environmentName = reader.string();
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -48575,7 +48687,8 @@ var SecretMetadata = {
     return {
       name: isSet5(object.name) ? globalThis.String(object.name) : "",
       creationInfo: isSet5(object.creationInfo) ? CreationInfo.fromJSON(object.creationInfo) : void 0,
-      keys: globalThis.Array.isArray(object?.keys) ? object.keys.map((e) => globalThis.String(e)) : []
+      keys: globalThis.Array.isArray(object?.keys) ? object.keys.map((e) => globalThis.String(e)) : [],
+      environmentName: isSet5(object.environmentName) ? globalThis.String(object.environmentName) : ""
     };
   },
   toJSON(message) {
@@ -48589,6 +48702,9 @@ var SecretMetadata = {
     if (message.keys?.length) {
       obj.keys = message.keys;
     }
+    if (message.environmentName !== "") {
+      obj.environmentName = message.environmentName;
+    }
     return obj;
   },
   create(base) {
@@ -48599,6 +48715,7 @@ var SecretMetadata = {
     message.name = object.name ?? "";
     message.creationInfo = object.creationInfo !== void 0 && object.creationInfo !== null ? CreationInfo.fromPartial(object.creationInfo) : void 0;
     message.keys = object.keys?.map((e) => e) || [];
+    message.environmentName = object.environmentName ?? "";
     return message;
   }
 };
@@ -61983,6 +62100,14 @@ var ModalClientDefinition = {
       responseStream: false,
       options: {}
     },
+    secretGetInfo: {
+      name: "SecretGetInfo",
+      requestType: SecretGetInfoRequest,
+      requestStream: false,
+      responseType: SecretGetInfoResponse,
+      responseStream: false,
+      options: {}
+    },
     secretGetOrCreate: {
       name: "SecretGetOrCreate",
       requestType: SecretGetOrCreateRequest,
@@ -70475,8 +70600,151 @@ var SandboxFilesystem = class {
 };
 
 // src/sandbox_sidecar.ts
-import { ClientError as ClientError9, Status as Status9 } from "nice-grpc";
+import { ClientError as ClientError10, Status as Status10 } from "nice-grpc";
 import { v4 as uuidv4 } from "uuid";
+
+// src/volume.ts
+import { ClientError as ClientError9, Status as Status9 } from "nice-grpc";
+var VolumeService = class {
+  #client;
+  constructor(client) {
+    this.#client = client;
+  }
+  /**
+   * Reference a {@link Volume} by its name.
+   */
+  async fromName(name, params) {
+    try {
+      const resp = await this.#client.cpClient.volumeGetOrCreate({
+        deploymentName: name,
+        environmentName: this.#client.environmentName(params?.environment),
+        objectCreationType: params?.createIfMissing ? 1 /* OBJECT_CREATION_TYPE_CREATE_IF_MISSING */ : 0 /* OBJECT_CREATION_TYPE_UNSPECIFIED */
+      });
+      this.#client.logger.debug(
+        "Retrieved Volume",
+        "volume_id",
+        resp.volumeId,
+        "volume_name",
+        name
+      );
+      return new Volume(resp.volumeId, name);
+    } catch (err) {
+      if (err instanceof ClientError9 && err.code === Status9.NOT_FOUND)
+        throw new NotFoundError(err.details);
+      throw err;
+    }
+  }
+  /**
+   * Create a nameless, temporary {@link Volume}.
+   * It persists until closeEphemeral() is called, or the process exits.
+   */
+  async ephemeral(params = {}) {
+    const resp = await this.#client.cpClient.volumeGetOrCreate({
+      objectCreationType: 5 /* OBJECT_CREATION_TYPE_EPHEMERAL */,
+      environmentName: this.#client.environmentName(params.environment)
+    });
+    this.#client.logger.debug(
+      "Created ephemeral Volume",
+      "volume_id",
+      resp.volumeId
+    );
+    const ephemeralHbManager = new EphemeralHeartbeatManager(
+      () => this.#client.cpClient.volumeHeartbeat({ volumeId: resp.volumeId })
+    );
+    return new Volume(resp.volumeId, void 0, void 0, ephemeralHbManager);
+  }
+  /**
+   * Delete a named {@link Volume}.
+   *
+   * Warning: Deletion is irreversible and will affect any Apps currently using the Volume.
+   */
+  async delete(name, params) {
+    try {
+      const volume = await this.fromName(name, {
+        environment: params?.environment,
+        createIfMissing: false
+      });
+      await this.#client.cpClient.volumeDelete({
+        volumeId: volume.volumeId
+      });
+      this.#client.logger.debug(
+        "Deleted Volume",
+        "volume_name",
+        name,
+        "volume_id",
+        volume.volumeId
+      );
+    } catch (err) {
+      const isNotFound = err instanceof NotFoundError || err instanceof ClientError9 && err.code === Status9.NOT_FOUND;
+      if (isNotFound && params?.allowMissing) {
+        return;
+      }
+      throw err;
+    }
+  }
+};
+var DEFAULT_MOUNT_OPTIONS = {
+  readOnly: false,
+  subPath: void 0
+};
+var Volume = class _Volume {
+  volumeId;
+  name;
+  /**
+   * @hidden
+   * @internal
+   */
+  _mountOptions = DEFAULT_MOUNT_OPTIONS;
+  #ephemeralHbManager;
+  /** @ignore */
+  constructor(volumeId, name, mountOptions, ephemeralHbManager) {
+    this.volumeId = volumeId;
+    this.name = name;
+    if (mountOptions) {
+      this._mountOptions = mountOptions;
+    }
+    this.#ephemeralHbManager = ephemeralHbManager;
+  }
+  /**
+   * Configure options used when mounting this Volume. Fields left undefined preserve their value
+   * from any previous withMountOptions call on the same Volume (stacking).
+   */
+  withMountOptions(params = {}) {
+    let subPath = this._mountOptions.subPath;
+    if (params.subPath !== void 0) {
+      subPath = params.subPath === "/" ? void 0 : params.subPath;
+    }
+    return new _Volume(
+      this.volumeId,
+      this.name,
+      {
+        readOnly: params.readOnly ?? this._mountOptions.readOnly,
+        subPath
+      },
+      this.#ephemeralHbManager
+    );
+  }
+  /** Delete the ephemeral Volume. Only usable with emphemeral Volumes. */
+  closeEphemeral() {
+    if (this.#ephemeralHbManager) {
+      this.#ephemeralHbManager.stop();
+    } else {
+      throw new InvalidError("Volume is not ephemeral.");
+    }
+  }
+};
+function volumeToMountProto(mountPath, volume) {
+  const opts = volume._mountOptions ?? DEFAULT_MOUNT_OPTIONS;
+  return {
+    volumeId: volume.volumeId,
+    mountPath,
+    allowBackgroundCommits: true,
+    readOnly: opts.readOnly,
+    subPath: opts.subPath
+  };
+}
+
+// src/sandbox_sidecar.ts
 var MAIN_CONTAINER_NAME = "main";
 var CONTAINER_WAIT_POLL_TIMEOUT_SECONDS = 10;
 var CONTROL_PLANE_SIDECAR_CREATE_ENV_VAR = "MODAL_USE_CONTROL_PLANE_SIDECAR_CREATE";
@@ -70493,6 +70761,29 @@ function validateSidecarName(name) {
     );
   }
 }
+function buildSidecarVolumeMounts(volumes) {
+  const mountPathsByVolumeId = /* @__PURE__ */ new Map();
+  const volumeMounts = [];
+  for (const [mountPath, volume] of Object.entries(volumes ?? {})) {
+    if (!volume) {
+      throw new InvalidError(
+        `Volume mounted at "${mountPath}" must not be null or undefined`
+      );
+    }
+    const mountPaths = mountPathsByVolumeId.get(volume.volumeId) ?? [];
+    mountPaths.push(mountPath);
+    mountPathsByVolumeId.set(volume.volumeId, mountPaths);
+    volumeMounts.push(volumeToMountProto(mountPath, volume));
+  }
+  for (const mountPaths of mountPathsByVolumeId.values()) {
+    if (mountPaths.length > 1) {
+      throw new InvalidError(
+        "The same Volume cannot be mounted at multiple paths in a sidecar: " + mountPaths.sort().join(", ")
+      );
+    }
+  }
+  return volumeMounts;
+}
 function sidecarContainerFromProto(access, info) {
   return new SidecarContainer(
     access,
@@ -70530,6 +70821,7 @@ var SidecarService = class {
     Object.assign(envDict, params?.env ?? {});
     await hydrateSecrets(this.#access.client, resolvableSecrets);
     const secretIds = collectSecretIds(resolvableSecrets);
+    const volumeMounts = buildSidecarVolumeMounts(params?.volumes);
     const ptyInfo = params?.pty ? defaultSandboxPTYInfo() : void 0;
     const networkAccess = buildOutboundNetworkAccess(
       false,
@@ -70549,6 +70841,7 @@ var SidecarService = class {
               entrypointArgs: command,
               workdir: params?.workdir ?? void 0,
               secretIds,
+              volumeMounts,
               networkAccess,
               ptyInfo
             }),
@@ -70566,17 +70859,18 @@ var SidecarService = class {
             env: envDict,
             workdir: params?.workdir ?? "",
             secretIds,
+            volumeMounts,
             networkAccess,
             ptyInfo
           })
         );
       }
     } catch (err) {
-      if (err instanceof ClientError9) {
-        if (err.code === Status9.ALREADY_EXISTS) {
+      if (err instanceof ClientError10) {
+        if (err.code === Status10.ALREADY_EXISTS) {
           throw new AlreadyExistsError(err.details || err.message);
         }
-        if (err.code === Status9.INVALID_ARGUMENT) {
+        if (err.code === Status10.INVALID_ARGUMENT) {
           throw new InvalidError(err.details || err.message);
         }
       }
@@ -70602,7 +70896,7 @@ var SidecarService = class {
         })
       );
     } catch (err) {
-      if (err instanceof ClientError9 && err.code === Status9.NOT_FOUND) {
+      if (err instanceof ClientError10 && err.code === Status10.NOT_FOUND) {
         throw new NotFoundError(`Sidecar container "${name}" not found`);
       }
       throw err;
@@ -70973,151 +71267,11 @@ var SandboxSnapshotService = class {
   }
 };
 
-// src/volume.ts
-import { ClientError as ClientError10, Status as Status10 } from "nice-grpc";
-var VolumeService = class {
-  #client;
-  constructor(client) {
-    this.#client = client;
-  }
-  /**
-   * Reference a {@link Volume} by its name.
-   */
-  async fromName(name, params) {
-    try {
-      const resp = await this.#client.cpClient.volumeGetOrCreate({
-        deploymentName: name,
-        environmentName: this.#client.environmentName(params?.environment),
-        objectCreationType: params?.createIfMissing ? 1 /* OBJECT_CREATION_TYPE_CREATE_IF_MISSING */ : 0 /* OBJECT_CREATION_TYPE_UNSPECIFIED */
-      });
-      this.#client.logger.debug(
-        "Retrieved Volume",
-        "volume_id",
-        resp.volumeId,
-        "volume_name",
-        name
-      );
-      return new Volume(resp.volumeId, name);
-    } catch (err) {
-      if (err instanceof ClientError10 && err.code === Status10.NOT_FOUND)
-        throw new NotFoundError(err.details);
-      throw err;
-    }
-  }
-  /**
-   * Create a nameless, temporary {@link Volume}.
-   * It persists until closeEphemeral() is called, or the process exits.
-   */
-  async ephemeral(params = {}) {
-    const resp = await this.#client.cpClient.volumeGetOrCreate({
-      objectCreationType: 5 /* OBJECT_CREATION_TYPE_EPHEMERAL */,
-      environmentName: this.#client.environmentName(params.environment)
-    });
-    this.#client.logger.debug(
-      "Created ephemeral Volume",
-      "volume_id",
-      resp.volumeId
-    );
-    const ephemeralHbManager = new EphemeralHeartbeatManager(
-      () => this.#client.cpClient.volumeHeartbeat({ volumeId: resp.volumeId })
-    );
-    return new Volume(resp.volumeId, void 0, void 0, ephemeralHbManager);
-  }
-  /**
-   * Delete a named {@link Volume}.
-   *
-   * Warning: Deletion is irreversible and will affect any Apps currently using the Volume.
-   */
-  async delete(name, params) {
-    try {
-      const volume = await this.fromName(name, {
-        environment: params?.environment,
-        createIfMissing: false
-      });
-      await this.#client.cpClient.volumeDelete({
-        volumeId: volume.volumeId
-      });
-      this.#client.logger.debug(
-        "Deleted Volume",
-        "volume_name",
-        name,
-        "volume_id",
-        volume.volumeId
-      );
-    } catch (err) {
-      const isNotFound = err instanceof NotFoundError || err instanceof ClientError10 && err.code === Status10.NOT_FOUND;
-      if (isNotFound && params?.allowMissing) {
-        return;
-      }
-      throw err;
-    }
-  }
-};
-var DEFAULT_MOUNT_OPTIONS = {
-  readOnly: false,
-  subPath: void 0
-};
-var Volume = class _Volume {
-  volumeId;
-  name;
-  /**
-   * @hidden
-   * @internal
-   */
-  _mountOptions = DEFAULT_MOUNT_OPTIONS;
-  #ephemeralHbManager;
-  /** @ignore */
-  constructor(volumeId, name, mountOptions, ephemeralHbManager) {
-    this.volumeId = volumeId;
-    this.name = name;
-    if (mountOptions) {
-      this._mountOptions = mountOptions;
-    }
-    this.#ephemeralHbManager = ephemeralHbManager;
-  }
-  /**
-   * Configure options used when mounting this Volume. Fields left undefined preserve their value
-   * from any previous withMountOptions call on the same Volume (stacking).
-   */
-  withMountOptions(params = {}) {
-    let subPath = this._mountOptions.subPath;
-    if (params.subPath !== void 0) {
-      subPath = params.subPath === "/" ? void 0 : params.subPath;
-    }
-    return new _Volume(
-      this.volumeId,
-      this.name,
-      {
-        readOnly: params.readOnly ?? this._mountOptions.readOnly,
-        subPath
-      },
-      this.#ephemeralHbManager
-    );
-  }
-  /** Delete the ephemeral Volume. Only usable with emphemeral Volumes. */
-  closeEphemeral() {
-    if (this.#ephemeralHbManager) {
-      this.#ephemeralHbManager.stop();
-    } else {
-      throw new InvalidError("Volume is not ephemeral.");
-    }
-  }
-};
-function volumeToMountProto(mountPath, volume) {
-  const opts = volume._mountOptions ?? DEFAULT_MOUNT_OPTIONS;
-  return {
-    volumeId: volume.volumeId,
-    mountPath,
-    allowBackgroundCommits: true,
-    readOnly: opts.readOnly,
-    subPath: opts.subPath
-  };
-}
-
 // src/sandbox.ts
 var SB_LOGS_INITIAL_DELAY_MS = 10;
 var SB_LOGS_DELAY_FACTOR = 2;
 var SB_LOGS_MAX_RETRIES = 10;
+var SB_LOGS_TASK_ID_TIMEOUT_SECONDS = 0.5;
 var TTL_NO_EXPIRY_SENTINEL = -1;
 var CUSTOMER_SUPPLIED_ENCRYPTION_KEY_MIN_LENGTH = 16;
 var CUSTOMER_SUPPLIED_ENCRYPTION_KEY_MAX_LENGTH = 512;
@@ -71975,6 +72129,7 @@ function buildTaskSnapshotDirectoryRequestProto(taskId, path2, snapshotId, ttlSe
 var Sandbox2 = class _Sandbox {
   #client;
   sandboxId;
+  #appId;
   #stdin;
   #stdout;
   #stderr;
@@ -72021,6 +72176,25 @@ var Sandbox2 = class _Sandbox {
     }
     return this.#stderr;
   }
+  /**
+   * Access persisted entrypoint logs emitted by this Sandbox.
+   *
+   * Use {@link SandboxLogsManager#fetch fetch()} to read logs from a UTC time
+   * range and {@link SandboxLogsManager#tail tail()} to read the most recent
+   * logs.
+   *
+   * This is separate from {@link Sandbox#stdout stdout} and
+   * {@link Sandbox#stderr stderr}, which expose the Sandbox's live output
+   * streams.
+   */
+  get logs() {
+    return new SandboxLogsManager(
+      this.#client,
+      this.sandboxId,
+      () => this.#getAppId(),
+      () => this.#resolveTaskIdForLogs()
+    );
+  }
   #outputStream(fileDescriptor) {
     if (this.#isV2) {
       this.#ensureAttached();
@@ -72253,8 +72427,11 @@ var Sandbox2 = class _Sandbox {
     }
     return this.#client.cpClient.sandboxWait(req);
   }
-  #sandboxGetTaskId(signal) {
-    const req = { sandboxId: this.sandboxId };
+  #sandboxGetTaskId(signal, timeout) {
+    const req = SandboxGetTaskIdRequest.create({
+      sandboxId: this.sandboxId,
+      timeout
+    });
     if (this.#isV2) {
       return this.#client.cpClient.sandboxGetTaskIdV2(req, { signal });
     }
@@ -72284,6 +72461,42 @@ var Sandbox2 = class _Sandbox {
   }
   static #maxGetTaskIdAttempts = 600;
   // 5 minutes at 500ms intervals
+  async #getAppId() {
+    if (this.#appId !== void 0) {
+      return this.#appId;
+    }
+    const resp = await this.#sandboxWait(0);
+    const appId = resp.metadata?.appId;
+    if (!appId) {
+      throw new ExecutionError(
+        "Sandbox app ID should have been set during hydration"
+      );
+    }
+    this.#appId = appId;
+    return appId;
+  }
+  async #resolveTaskIdForLogs() {
+    if (this.#taskId !== void 0) {
+      return this.#taskId;
+    }
+    let resp;
+    try {
+      resp = await this.#sandboxGetTaskId(
+        void 0,
+        SB_LOGS_TASK_ID_TIMEOUT_SECONDS
+      );
+    } catch (error) {
+      if (error instanceof ClientError11 && error.code === Status11.DEADLINE_EXCEEDED) {
+        throw new ExecutionError("Sandbox task ID is not available yet.");
+      }
+      throw error;
+    }
+    if (!resp.taskId) {
+      throw new ExecutionError("Sandbox task ID is not available.");
+    }
+    this.#taskId = resp.taskId;
+    return this.#taskId;
+  }
   async #getTaskId(signal) {
     if (this.#taskId !== void 0) {
       return this.#taskId;
@@ -73292,7 +73505,7 @@ var AuthTokenManager = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.10.2-dev.5";
+var SDK_VERSION = "0.10.2-dev.7";
 function getSDKVersion() {
   return SDK_VERSION;
 }
@@ -74038,6 +74251,8 @@ function contextIds(batch, item, ObjectId) {
         item.inputId || batch.inputId,
         item.containerId || batch.taskId
       ].filter((id) => id);
+    case "sb":
+      return [item.containerId || batch.taskId].filter((id) => id);
     default:
       return [];
   }
@@ -74858,6 +75073,97 @@ var FunctionCallLogsManager = class extends LogsManager {
     );
   }
 };
+var SandboxLogsManager = class {
+  /** @ignore */
+  constructor(client, sandboxId, getAppId, getTaskId) {
+    this.client = client;
+    this.sandboxId = sandboxId;
+    this.getAppId = getAppId;
+    this.getTaskId = getTaskId;
+  }
+  /**
+   * Fetch Sandbox entrypoint logs corresponding to a UTC time range and
+   * optional filters.
+   *
+   * Entries are returned in chronological order.
+   *
+   * @returns An async iterable of {@link LogEntry} objects.
+   *
+   * @example
+   * ```typescript
+   * import { ModalClient } from "modal";
+   *
+   * const modal = new ModalClient();
+   * const sandbox = await modal.sandboxes.fromId("sb-...");
+   *
+   * for await (const entry of sandbox.logs.fetch({
+   *   since: new Date(Date.now() - 60 * 60 * 1_000),
+   *   source: "stdout",
+   * })) {
+   *   process.stdout.write(entry.message);
+   * }
+   * ```
+   */
+  async *fetch(params) {
+    const [appId, taskId] = await Promise.all([
+      this.getAppId(),
+      this.getTaskId()
+    ]);
+    if (!taskId) {
+      throw new ExecutionError(
+        "Cannot resolve Sandbox metadata needed for fetching logs. Wait for the Sandbox to be scheduled."
+      );
+    }
+    yield* fetchLogs(
+      this.client,
+      {
+        appId,
+        objectId: this.sandboxId,
+        taskId,
+        source: sourceToFileDescriptor(params.source),
+        searchText: params.searchText
+      },
+      params.since,
+      params.until
+    );
+  }
+  /**
+   * Fetch the most recent Sandbox entrypoint logs.
+   *
+   * Entries are returned in chronological order.
+   *
+   * @returns An async iterable of {@link LogEntry} objects.
+   *
+   * @example
+   * ```typescript
+   * import { ModalClient } from "modal";
+   *
+   * const modal = new ModalClient();
+   * const sandbox = await modal.sandboxes.fromId("sb-...");
+   *
+   * for await (const entry of sandbox.logs.tail({ entries: 20 })) {
+   *   process.stdout.write(entry.message);
+   * }
+   * ```
+   */
+  async *tail(params = {}) {
+    const [appId, taskId] = await Promise.all([
+      this.getAppId(),
+      this.getTaskId()
+    ]);
+    if (!taskId) {
+      throw new ExecutionError(
+        "Sandbox task ID cannot be empty when fetching logs. Wait for the Sandbox to be scheduled."
+      );
+    }
+    yield* tailLogs(this.client, params.entries ?? 100, {
+      appId,
+      objectId: this.sandboxId,
+      taskId,
+      source: sourceToFileDescriptor(params.source)
+    });
+  }
+};
 
 // src/function_call.ts
 var FunctionCallService = class {
@@ -75794,6 +76100,7 @@ export {
   SandboxFilesystemNotFoundError,
   SandboxFilesystemPathAlreadyExistsError,
   SandboxFilesystemPermissionError,
+  SandboxLogsManager,
   SandboxService,
   SandboxSnapshot,
   SandboxSnapshotService,