modal 0.3.7 → 0.3.8

package/dist/index.js

@@ -37797,13 +37797,13 @@ import {
 } from "nice-grpc";
 
 // src/config.ts
-import { readFile } from "node:fs/promises";
-import path from "node:path";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
+import path from "node:path";
 import { parse as parseToml } from "smol-toml";
-async function readConfigFile() {
+function readConfigFile() {
   try {
-    const configContent = await readFile(path.join(homedir(), ".modal.toml"), {
+    const configContent = readFileSync(path.join(homedir(), ".modal.toml"), {
       encoding: "utf-8"
     });
     return parseToml(configContent);
@@ -37814,7 +37814,7 @@ async function readConfigFile() {
     throw new Error(`Failed to read or parse .modal.toml: ${err.message}`);
   }
 }
-var config = await readConfigFile();
+var config = readConfigFile();
 function getProfile(profileName) {
   profileName = profileName || process.env["MODAL_PROFILE"] || void 0;
   if (!profileName) {
@@ -38505,31 +38505,6 @@ import { ClientError as ClientError5, Status as Status5 } from "nice-grpc";
 // src/function.ts
 import { createHash } from "node:crypto";
 
-// src/function_call.ts
-var FunctionCall = class _FunctionCall {
-  functionCallId;
-  /** @ignore */
-  constructor(functionCallId) {
-    this.functionCallId = functionCallId;
-  }
-  /** Create a new function call from ID. */
-  fromId(functionCallId) {
-    return new _FunctionCall(functionCallId);
-  }
-  /** Get the result of a function call, optionally waiting with a timeout. */
-  async get(options = {}) {
-    const timeout = options.timeout;
-    return await pollFunctionOutput(this.functionCallId, timeout);
-  }
-  /** Cancel a running function call. */
-  async cancel(options = {}) {
-    await client.functionCallCancel({
-      functionCallId: this.functionCallId,
-      terminateContainers: options.terminateContainers
-    });
-  }
-};
-
 // src/pickle.ts
 var PickleError = class extends Error {
   constructor(message) {
@@ -38877,79 +38852,62 @@ function loads(buf) {
   throw new PickleError("pickle stream ended without STOP");
 }
 
-// src/function.ts
-import { ClientError as ClientError4, Status as Status4 } from "nice-grpc";
-var maxObjectSizeBytes = 2 * 1024 * 1024;
+// src/invocation.ts
 var outputsTimeout = 55 * 1e3;
-function timeNowSeconds() {
-  return Date.now() / 1e3;
-}
-var Function_ = class _Function_ {
-  functionId;
-  methodName;
-  /** @ignore */
-  constructor(functionId, methodName) {
-    this.functionId = functionId;
-    this.methodName = methodName;
-  }
-  static async lookup(appName, name, options = {}) {
-    try {
-      const resp = await client.functionGet({
-        appName,
-        objectTag: name,
-        namespace: 1 /* DEPLOYMENT_NAMESPACE_WORKSPACE */,
-        environmentName: environmentName(options.environment)
-      });
-      return new _Function_(resp.functionId);
-    } catch (err) {
-      if (err instanceof ClientError4 && err.code === Status4.NOT_FOUND)
-        throw new NotFoundError(`Function '${appName}/${name}' not found`);
-      throw err;
-    }
+var ControlPlaneInvocation = class _ControlPlaneInvocation {
+  functionCallId;
+  input;
+  functionCallJwt;
+  inputJwt;
+  constructor(functionCallId, input, functionCallJwt, inputJwt) {
+    this.functionCallId = functionCallId;
+    this.input = input;
+    this.functionCallJwt = functionCallJwt;
+    this.inputJwt = inputJwt;
   }
-  // Execute a single input into a remote Function.
-  async remote(args = [], kwargs = {}) {
-    const functionCallId = await this.#execFunctionCall(
-      args,
-      kwargs,
-      4 /* FUNCTION_CALL_INVOCATION_TYPE_SYNC */
+  static async create(functionId, input, invocationType) {
+    const functionPutInputsItem = {
+      idx: 0,
+      input
+    };
+    const functionMapResponse = await client.functionMap({
+      functionId,
+      functionCallType: 1 /* FUNCTION_CALL_TYPE_UNARY */,
+      functionCallInvocationType: invocationType,
+      pipelinedInputs: [functionPutInputsItem]
+    });
+    return new _ControlPlaneInvocation(
+      functionMapResponse.functionCallId,
+      input,
+      functionMapResponse.functionCallJwt,
+      functionMapResponse.pipelinedInputs[0].inputJwt
     );
-    return await pollFunctionOutput(functionCallId);
   }
-  // Spawn a single input into a remote function.
-  async spawn(args = [], kwargs = {}) {
-    const functionCallId = await this.#execFunctionCall(
-      args,
-      kwargs,
-      4 /* FUNCTION_CALL_INVOCATION_TYPE_SYNC */
-    );
-    return new FunctionCall(functionCallId);
+  static fromFunctionCallId(functionCallId) {
+    return new _ControlPlaneInvocation(functionCallId);
   }
-  async #execFunctionCall(args = [], kwargs = {}, invocationType = 4 /* FUNCTION_CALL_INVOCATION_TYPE_SYNC */) {
-    const payload = dumps([args, kwargs]);
-    let argsBlobId = void 0;
-    if (payload.length > maxObjectSizeBytes) {
-      argsBlobId = await blobUpload(payload);
+  async awaitOutput(timeout) {
+    return await pollFunctionOutput(this.functionCallId, timeout);
+  }
+  async retry(retryCount) {
+    if (!this.input) {
+      throw new Error("Cannot retry function invocation - input missing");
     }
-    const functionMapResponse = await client.functionMap({
-      functionId: this.functionId,
-      functionCallType: 1 /* FUNCTION_CALL_TYPE_UNARY */,
-      functionCallInvocationType: invocationType,
-      pipelinedInputs: [
-        {
-          idx: 0,
-          input: {
-            args: argsBlobId ? void 0 : payload,
-            argsBlobId,
-            dataFormat: 1 /* DATA_FORMAT_PICKLE */,
-            methodName: this.methodName
-          }
-        }
-      ]
+    const retryItem = {
+      inputJwt: this.inputJwt,
+      input: this.input,
+      retryCount
+    };
+    const functionRetryResponse = await client.functionRetryInputs({
+      functionCallJwt: this.functionCallJwt,
+      inputs: [retryItem]
     });
-    return functionMapResponse.functionCallId;
+    this.inputJwt = functionRetryResponse.inputJwts[0];
   }
 };
+function timeNowSeconds() {
+  return Date.now() / 1e3;
+}
 async function pollFunctionOutput(functionCallId, timeout) {
   const startTime = Date.now();
   let pollTimeout = outputsTimeout;
@@ -39007,6 +38965,134 @@ async function processResult(result, dataFormat) {
   }
   return deserializeDataFormat(data, dataFormat);
 }
+async function blobDownload(blobId) {
+  const resp = await client.blobGet({ blobId });
+  const s3resp = await fetch(resp.downloadUrl);
+  if (!s3resp.ok) {
+    throw new Error(`Failed to download blob: ${s3resp.statusText}`);
+  }
+  const buf = await s3resp.arrayBuffer();
+  return new Uint8Array(buf);
+}
+function deserializeDataFormat(data, dataFormat) {
+  if (!data) {
+    return null;
+  }
+  switch (dataFormat) {
+    case 1 /* DATA_FORMAT_PICKLE */:
+      return loads(data);
+    case 2 /* DATA_FORMAT_ASGI */:
+      throw new Error("ASGI data format is not supported in Go");
+    case 3 /* DATA_FORMAT_GENERATOR_DONE */:
+      return GeneratorDone.decode(data);
+    default:
+      throw new Error(`Unsupported data format: ${dataFormat}`);
+  }
+}
+
+// src/function_call.ts
+var FunctionCall = class _FunctionCall {
+  functionCallId;
+  /** @ignore */
+  constructor(functionCallId) {
+    this.functionCallId = functionCallId;
+  }
+  /** Create a new function call from ID. */
+  fromId(functionCallId) {
+    return new _FunctionCall(functionCallId);
+  }
+  /** Get the result of a function call, optionally waiting with a timeout. */
+  async get(options = {}) {
+    const timeout = options.timeout;
+    const invocation = ControlPlaneInvocation.fromFunctionCallId(
+      this.functionCallId
+    );
+    return invocation.awaitOutput(timeout);
+  }
+  /** Cancel a running function call. */
+  async cancel(options = {}) {
+    await client.functionCallCancel({
+      functionCallId: this.functionCallId,
+      terminateContainers: options.terminateContainers
+    });
+  }
+};
+
+// src/function.ts
+import { ClientError as ClientError4, Status as Status4 } from "nice-grpc";
+var maxObjectSizeBytes = 2 * 1024 * 1024;
+var maxSystemRetries = 8;
+var Function_ = class _Function_ {
+  functionId;
+  methodName;
+  /** @ignore */
+  constructor(functionId, methodName) {
+    this.functionId = functionId;
+    this.methodName = methodName;
+  }
+  static async lookup(appName, name, options = {}) {
+    try {
+      const resp = await client.functionGet({
+        appName,
+        objectTag: name,
+        namespace: 1 /* DEPLOYMENT_NAMESPACE_WORKSPACE */,
+        environmentName: environmentName(options.environment)
+      });
+      return new _Function_(resp.functionId);
+    } catch (err) {
+      if (err instanceof ClientError4 && err.code === Status4.NOT_FOUND)
+        throw new NotFoundError(`Function '${appName}/${name}' not found`);
+      throw err;
+    }
+  }
+  // Execute a single input into a remote Function.
+  async remote(args = [], kwargs = {}) {
+    const input = await this.#createInput(args, kwargs);
+    const invocation = await ControlPlaneInvocation.create(
+      this.functionId,
+      input,
+      4 /* FUNCTION_CALL_INVOCATION_TYPE_SYNC */
+    );
+    let retryCount = 0;
+    while (true) {
+      try {
+        return await invocation.awaitOutput();
+      } catch (err) {
+        if (err instanceof InternalFailure && retryCount <= maxSystemRetries) {
+          await invocation.retry(retryCount);
+          retryCount++;
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+  // Spawn a single input into a remote function.
+  async spawn(args = [], kwargs = {}) {
+    const input = await this.#createInput(args, kwargs);
+    const invocation = await ControlPlaneInvocation.create(
+      this.functionId,
+      input,
+      3 /* FUNCTION_CALL_INVOCATION_TYPE_ASYNC */
+    );
+    return new FunctionCall(invocation.functionCallId);
+  }
+  async #createInput(args = [], kwargs = {}) {
+    const payload = dumps([args, kwargs]);
+    let argsBlobId = void 0;
+    if (payload.length > maxObjectSizeBytes) {
+      argsBlobId = await blobUpload(payload);
+    }
+    return {
+      args: argsBlobId ? void 0 : payload,
+      argsBlobId,
+      dataFormat: 1 /* DATA_FORMAT_PICKLE */,
+      methodName: this.methodName,
+      finalInput: false
+      // This field isn't specified in the Python client, so it defaults to false.
+    };
+  }
+};
 async function blobUpload(data) {
   const contentMd5 = createHash("md5").update(data).digest("base64");
   const contentSha256 = createHash("sha256").update(data).digest("base64");
@@ -39036,30 +39122,6 @@ async function blobUpload(data) {
     throw new Error("Missing upload URL in BlobCreate response");
   }
 }
-async function blobDownload(blobId) {
-  const resp = await client.blobGet({ blobId });
-  const s3resp = await fetch(resp.downloadUrl);
-  if (!s3resp.ok) {
-    throw new Error(`Failed to download blob: ${s3resp.statusText}`);
-  }
-  const buf = await s3resp.arrayBuffer();
-  return new Uint8Array(buf);
-}
-function deserializeDataFormat(data, dataFormat) {
-  if (!data) {
-    return null;
-  }
-  switch (dataFormat) {
-    case 1 /* DATA_FORMAT_PICKLE */:
-      return loads(data);
-    case 2 /* DATA_FORMAT_ASGI */:
-      throw new Error("ASGI data format is not supported in Go");
-    case 3 /* DATA_FORMAT_GENERATOR_DONE */:
-      return GeneratorDone.decode(data);
-    default:
-      throw new Error(`Unsupported data format: ${dataFormat}`);
-  }
-}
 
 // src/cls.ts
 var Cls = class _Cls {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "modal",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "Modal client library for JavaScript",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "homepage": "https://modal.com/docs",
   "repository": "github:modal-labs/libmodal",
   "bugs": "https://github.com/modal-labs/libmodal/issues",