@alchemy.run/modal 0.0.0-stage → 2.0.0-beta.86

package/src/ImagePlan.ts

@@ -0,0 +1,78 @@
+import * as BuildPlan from "@alchemy.run/docker/BuildPlan";
+import * as DockerfileParser from "@alchemy.run/docker/DockerfileParser";
+import * as Effect from "effect/Effect";
+import type { ImageBuildSpec } from "./ImageBuild.ts";
+
+/*
+ * Deploy-time image planning. Kept out of ImageBuild.ts because
+ * `@alchemy.run/docker/BuildPlan` imports the bundler, which must never
+ * reach a runtime bundle.
+ */
+
+/**
+ * What Modal's image builder runs. It isn't Docker: it ignores `USER`
+ * (containers run as root), doesn't implement `EXPOSE`, `HEALTHCHECK`,
+ * `LABEL`, `ONBUILD`, `STOPSIGNAL` or `VOLUME`, has no BuildKit mounts, and
+ * builds `linux/amd64` images. A Dockerfile outside this fails at plan with
+ * the offending lines.
+ */
+export const MODAL_CAPABILITIES: BuildPlan.Capabilities = {
+  target: "Modal.Image",
+  multiStage: false,
+  heredocs: false,
+  runMounts: false,
+  platforms: ["linux/amd64"],
+  instructions: {
+    USER: "ignored",
+    EXPOSE: "unsupported",
+    HEALTHCHECK: "unsupported",
+    LABEL: "unsupported",
+    ONBUILD: "unsupported",
+    STOPSIGNAL: "unsupported",
+    VOLUME: "unsupported",
+  },
+};
+
+/**
+ * Lower a {@link BuildPlan.BuildPlan} to Modal's build inputs: the plan's
+ * Dockerfile as commands, every context file it reads, and its build args.
+ * `extra` lines (already checked) follow the plan's instructions.
+ */
+export const lowerPlan = Effect.fn(function* (
+  plan: BuildPlan.BuildPlan,
+  extra: ReadonlyArray<string> = [],
+) {
+  const contextFiles = yield* Effect.forEach(plan.files, (file) =>
+    Effect.map(BuildPlan.readContextFile(file), (data) => ({
+      filename: file.path,
+      data,
+      mode: file.mode,
+    })),
+  );
+  return {
+    commands: [...BuildPlan.renderLines(plan), ...extra],
+    contextFiles,
+    buildArgs: plan.args,
+  } satisfies ImageBuildSpec;
+});
+
+/**
+ * Parse and check Dockerfile lines appended to a plan (`commands`), the way
+ * {@link BuildPlan.plan} checks the Dockerfile itself.
+ */
+export const checkCommands = Effect.fn(function* (commands: ReadonlyArray<string>) {
+  if (commands.length === 0) return [] as string[];
+  const parsed = yield* DockerfileParser.parse(`FROM scratch\n${commands.join("\n")}\n`);
+  const { violations } = BuildPlan.check(parsed, MODAL_CAPABILITIES, "linux/amd64");
+  if (violations.length > 0) {
+    return yield* new BuildPlan.UnsupportedDockerfile({
+      target: MODAL_CAPABILITIES.target,
+      violations,
+      message: [
+        `${MODAL_CAPABILITIES.target} cannot build these commands:`,
+        ...violations.map((v) => `  ${v.instruction}: ${v.reason}`),
+      ].join("\n"),
+    });
+  }
+  return DockerfileParser.renderLines(parsed).slice(1);
+});

package/src/InferEnv.ts

@@ -0,0 +1,27 @@
+import type * as Effect from "effect/Effect";
+
+/**
+ * The `process.env` an async `Modal.Sandbox` program sees: one string per
+ * `env` entry of the declaration.
+ *
+ * @example
+ * ```ts
+ * // alchemy.run.ts
+ * export const Agent = Modal.Sandbox("Agent", { main: "./src/agent.ts", app: Coder, env: { GREETING: "hi" } });
+ * export type AgentEnv = Modal.InferEnv<typeof Agent>;
+ *
+ * // src/agent.ts
+ * import type { AgentEnv } from "../alchemy.run.ts";
+ * const env = process.env as unknown as AgentEnv;
+ * ```
+ */
+export type InferEnv<F> =
+  F extends Effect.Effect<infer A, infer _E, infer _R>
+    ? InferEnv<A>
+    : F extends { readonly Props: { readonly env?: infer E } }
+      ? InferEnvRecord<Exclude<E, undefined>>
+      : InferEnvRecord<F>;
+
+type InferEnvRecord<E> = {
+  readonly [K in keyof E]: string;
+};

package/src/InvokeFunction.ts

@@ -0,0 +1,211 @@
+import * as Binding from "alchemy/Binding";
+import type { Input } from "alchemy/Input";
+import type { Rpc } from "alchemy/Rpc";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import * as Data from "effect/Data";
+import type * as Effect from "effect/Effect";
+import type { downloadBlob, uploadBlob } from "./Blob.ts";
+import type { Function } from "./Function.ts";
+import type { FunctionLookupError } from "./FunctionTarget.ts";
+import type { ErrorOf, OpError } from "./internal.ts";
+import type { InvokeOps } from "./InvokeFunctionHttp.ts";
+
+/** A function deployed outside the Stack (`modal deploy`), by name. */
+export interface FunctionRef {
+  /** Name of the deployed App (`modal deploy` / `modal.App("…")`). */
+  readonly app: string;
+  /** Function name in the App (`"embed"`), or `"Class.method"` for a class method. */
+  readonly function: string;
+  /** Environment the App is deployed in. @default the workspace default */
+  readonly environment?: string;
+  /**
+   * Parameters of a parameterized class (`modal.parameter()` fields), for a
+   * `"Class.method"` target. Modal runs one set of containers per value set.
+   */
+  readonly parameters?: Record<string, string | number | boolean | Uint8Array>;
+}
+
+/** What a function binding targets: a `Modal.Function` of the Stack, or a deployed function by name. */
+export type FunctionTarget = Function | FunctionRef;
+
+/** The function raised, or Modal failed the call. */
+export class FunctionCallFailed extends Data.TaggedError("Modal.FunctionCallFailed")<{
+  readonly status: string;
+  readonly message: string;
+  readonly traceback?: string;
+}> {}
+
+/** Calling a function: looking it up, sending inputs, reading outputs, and the call's own failure. */
+export type InvokeError =
+  | FunctionLookupError
+  | OpError<InvokeOps, "map" | "putInputs" | "getOutputs">
+  | ErrorOf<typeof uploadBlob | typeof downloadBlob>
+  | FunctionCallFailed
+  | FunctionCallTimeout;
+
+/** The call didn't finish within its timeout. */
+export class FunctionCallTimeout extends Data.TaggedError("Modal.FunctionCallTimeout")<{
+  readonly functionCallId: string;
+  readonly message: string;
+}> {}
+
+/** Options for one call. */
+export interface CallOptions {
+  /** How long to wait for the result (seconds, or `"10 minutes"`). @default 300 seconds */
+  readonly timeout?: number | string;
+}
+
+/** Call one function. Arguments and results travel as CBOR. */
+export interface FunctionClient {
+  /** Call the function and wait for its result. */
+  call<A = unknown>(
+    args?: ReadonlyArray<unknown>,
+    kwargs?: Record<string, unknown>,
+    options?: CallOptions,
+  ): Effect.Effect<A, InvokeError, RuntimeContext>;
+  /**
+   * Call the function once per input, in parallel across containers, and
+   * return the results in input order. Each input is a list of positional
+   * arguments. Fails with the first failed input.
+   */
+  map<A = unknown>(
+    inputs: ReadonlyArray<ReadonlyArray<unknown>>,
+    options?: CallOptions,
+  ): Effect.Effect<A[], InvokeError, RuntimeContext>;
+  /** Start a call without waiting; read it later with {@link result}. */
+  spawn(
+    args?: ReadonlyArray<unknown>,
+    kwargs?: Record<string, unknown>,
+  ): Effect.Effect<{ readonly functionCallId: string }, InvokeError, RuntimeContext>;
+  /** The result of a spawned call, waiting up to `timeout`. */
+  result<A = unknown>(
+    call: { readonly functionCallId: string },
+    options?: CallOptions,
+  ): Effect.Effect<A, InvokeError, RuntimeContext>;
+  /** Cancel a spawned call. */
+  cancel(call: {
+    readonly functionCallId: string;
+  }): Effect.Effect<void, FunctionLookupError | OpError<InvokeOps, "cancel">, RuntimeContext>;
+}
+
+/**
+ * The RPC methods of a `Modal.Function` program: every function it returns
+ * besides `fetch` and `run`, called through Modal with the same arguments
+ * and results.
+ */
+export type FunctionStub<Shape> = Omit<Shape, "fetch" | "run">;
+
+/**
+ * Call a Modal Function from any runtime: a Worker, a Lambda, a Durable
+ * Object, another Modal Function. Bind a `Modal.Function` of the Stack, or
+ * a function deployed with `modal deploy` by name.
+ *
+ * A `Modal.Function` program's RPC methods come back as a typed client:
+ * each call goes through Modal (queued, retried and autoscaled like any
+ * Modal call) to the method of that name. Arguments and results are JSON
+ * values, and a typed failure reaches the caller by its `_tag`. A method
+ * that returns a `Stream` arrives whole, once the call finishes. The
+ * binding gives the host its own key for the function, which every call
+ * carries: the program answers only callers bound to it.
+ *
+ * A Python function, or an async program, gets a {@link FunctionClient}
+ * instead: `call`, `map` and `spawn` with CBOR arguments (Modal's
+ * cross-language format). Payloads over 2 MiB go through Modal's blob store.
+ *
+ * ### Call a function
+ * **Example:** RPC methods of a `Modal.Function`
+ * ```typescript
+ * // src/Embed.ts
+ * import * as Modal from "@alchemy.run/modal";
+ * import * as Effect from "effect/Effect";
+ * import { Inference } from "./Inference.ts";
+ *
+ * export default class Embed extends Modal.Function<Embed>()(
+ *   "Embed",
+ *   { main: import.meta.url, app: Inference },
+ *   Effect.gen(function* () {
+ *     return {
+ *       embed: Effect.fn(function* (text: string) {
+ *         return { tokens: text.split(/\s+/).length };
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * **Example:** Call it from a Cloudflare Worker
+ * ```typescript
+ * import * as Cloudflare from "@alchemy.run/cloudflare";
+ * import * as Modal from "@alchemy.run/modal";
+ * import * as Effect from "effect/Effect";
+ * import * as HttpServerResponse from "effect/http/HttpServerResponse";
+ * import Embed from "./Embed.ts";
+ *
+ * export default class Api extends Cloudflare.Worker<Api>()(
+ *   "Api",
+ *   { main: import.meta.url, compatibility: { flags: ["nodejs_compat"] } },
+ *   Effect.gen(function* () {
+ *     const embed = yield* Modal.InvokeFunction(Embed);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const { tokens } = yield* embed.embed("hello world");
+ *         return yield* HttpServerResponse.json({ tokens });
+ *       }).pipe(Effect.orDie),
+ *     };
+ *   }).pipe(Effect.provide(Modal.InvokeFunctionHttp)),
+ * ) {}
+ * ```
+ *
+ * **Example:** A Python function deployed with `modal deploy`
+ * ```typescript
+ * const embed = yield* Modal.InvokeFunction({ app: "inference", function: "embed" });
+ * const vector = yield* embed.call<number[]>(["hello world"]);
+ * ```
+ *
+ * **Example:** A method of a parameterized Python class
+ * ```typescript
+ * const model = yield* Modal.InvokeFunction({
+ *   app: "inference",
+ *   function: "Model.generate",
+ *   parameters: { size: "7b" },
+ * });
+ * const text = yield* model.call<string>(["hello"]);
+ * ```
+ *
+ * ### Fan out
+ * **Example:** One call per input, in parallel
+ * ```typescript
+ * const results = yield* embed.map<{ tokens: number }>([["a"], ["b"], ["c"]]);
+ * ```
+ *
+ * ### Fire and forget
+ * **Example:** Spawn, then read the result later
+ * ```typescript
+ * const job = yield* train.spawn([], { epochs: 3 });
+ * const metrics = yield* train.result(job, { timeout: "30 minutes" });
+ * ```
+ *
+ * @binding
+ * @product Function
+ */
+export interface InvokeFunction extends Binding.Service<
+  InvokeFunction,
+  "Modal.InvokeFunction",
+  (target: FunctionTarget) => Effect.Effect<FunctionClient>
+> {}
+
+/** InvokeFunction's call signatures, typed from the target's program. */
+export interface InvokeFunctionCall {
+  /** A `Modal.Function` of the Stack whose program has RPC methods: its typed client. */
+  <Shape, Req = never>(
+    target: (Function & Rpc<Shape>) | Effect.Effect<Function & Rpc<Shape>, never, Req>,
+  ): Effect.Effect<FunctionStub<Shape>, never, InvokeFunction | Req>;
+  /** A deployed function by name, or an async program: `call`, `map` and `spawn`. */
+  <Req = never>(
+    target: Input<FunctionTarget> | Effect.Effect<FunctionTarget, never, Req>,
+  ): Effect.Effect<FunctionClient, never, InvokeFunction | Req>;
+}
+
+export const InvokeFunction = Binding.Service<InvokeFunction>(
+  "Modal.InvokeFunction",
+) as unknown as InvokeFunctionCall & InvokeFunction;

package/src/InvokeFunctionHttp.ts

@@ -0,0 +1,316 @@
+import * as functions from "@distilled.cloud/modal/functions";
+import {
+  asEffectOrStream,
+  decodeRpcResponseStream,
+  decodeRpcResult,
+  RpcCallError,
+} from "alchemy/Rpc";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { BlobOps, downloadBlob, MAX_INLINE_BYTES, uploadBlob } from "./Blob.ts";
+import { decodeCbor, encodeCbor } from "./Cbor.ts";
+import { isFunctionRef, makeFunctionBinding, type ResolvedFunction } from "./FunctionTarget.ts";
+import { operations, seconds } from "./internal.ts";
+import { RPC_STREAM_KEY } from "./internal/Entrypoint.ts";
+import { RPC_KEY_KWARG, RpcCaller } from "./internal/RpcAuth.ts";
+import {
+  FunctionCallFailed,
+  FunctionCallTimeout,
+  InvokeFunction,
+  type CallOptions,
+  type FunctionClient,
+  type FunctionTarget,
+} from "./InvokeFunction.ts";
+
+/** The operations the client calls, resolved by `ModalBindings.withCredentials`. */
+const InvokeOps = operations({
+  map: functions.functionMap,
+  putInputs: functions.functionPutInputs,
+  getOutputs: functions.getFunctionOutputs,
+  cancel: functions.cancelFunctionCall,
+  blobs: BlobOps,
+});
+
+export type InvokeOps = Effect.Success<typeof InvokeOps>;
+
+/** One input: CBOR `[args, kwargs]`, inline or (over 2 MiB) as a blob. */
+const encodeInput = Effect.fn(function* (
+  blobs: BlobOps,
+  args: ReadonlyArray<unknown>,
+  kwargs: Record<string, unknown>,
+  method: string | undefined,
+) {
+  const bytes = yield* Effect.try({
+    try: () => encodeCbor([args, kwargs]),
+    catch: (cause) =>
+      new FunctionCallFailed({
+        status: "INVALID_ARGUMENTS",
+        message: `Arguments aren't CBOR-encodable: ${String(cause)}`,
+      }),
+  });
+  const payload =
+    bytes.length > MAX_INLINE_BYTES
+      ? { argsBlobId: yield* uploadBlob(blobs, bytes) }
+      : { args: yield* Effect.sync(() => Buffer.from(bytes).toString("base64")) };
+  return {
+    ...payload,
+    dataFormat: "DATA_FORMAT_CBOR",
+    methodName: method,
+  } satisfies functions.FunctionInput;
+});
+
+/** The value of a finished output, or its failure. */
+const decodeOutput = Effect.fn(function* (
+  blobs: BlobOps,
+  functionCallId: string,
+  output: functions.GetFunctionOutputsItem,
+) {
+  const result = output.result;
+  if (result?.status !== "GENERIC_STATUS_SUCCESS") {
+    return yield* new FunctionCallFailed({
+      status: result?.status ?? "GENERIC_STATUS_UNSPECIFIED",
+      message: result?.exception || `Function call ${functionCallId} failed`,
+      traceback: result?.traceback,
+    });
+  }
+  const bytes = result.dataBlobId
+    ? yield* downloadBlob(blobs, result.dataBlobId)
+    : result.data
+      ? yield* Effect.sync(() => new Uint8Array(Buffer.from(result.data!, "base64")))
+      : undefined;
+  if (bytes === undefined) return null;
+  return yield* Effect.try({
+    try: () => decodeCbor(bytes),
+    catch: (cause) =>
+      new FunctionCallFailed({
+        status: "INVALID_RESULT",
+        message: `The result isn't CBOR (return plain values, or set the function's serialization): ${String(cause)}`,
+      }),
+  });
+});
+
+/** Inputs per `FunctionPutInputs` request. */
+const BATCH = 49;
+
+/** A client for a resolved function. */
+export const makeFunctionClient = (resolved: ResolvedFunction, ops: InvokeOps): FunctionClient => {
+  const { functionId, method } = resolved;
+
+  /** Collect `count` outputs of a call, by input index. */
+  const collect = Effect.fn(function* (
+    functionCallId: string,
+    count: number,
+    timeout: number | string | undefined,
+  ) {
+    const budget = seconds(timeout) ?? 300;
+    const rounds = Math.max(1, Math.ceil(budget / 55));
+    const values = new Map<number, unknown>();
+    let lastEntryId = "0-0";
+    for (let round = 0; round < rounds && values.size < count; round++) {
+      const response = yield* ops.getOutputs({
+        functionCallId,
+        maxValues: Math.min(1000, count - values.size),
+        timeout: Math.min(55, budget),
+        lastEntryId,
+        // A map's outputs stay until all are read; a single output is popped.
+        clearOnSuccess: count === 1,
+      });
+      if (response.lastEntryId) lastEntryId = response.lastEntryId;
+      for (const output of response.outputs ?? []) {
+        if (!output.result) continue;
+        values.set(output.idx ?? 0, yield* decodeOutput(ops.blobs, functionCallId, output));
+      }
+    }
+    if (values.size < count) {
+      return yield* new FunctionCallTimeout({
+        functionCallId,
+        message: `Function call ${functionCallId} didn't finish within ${budget} seconds`,
+      });
+    }
+    return Array.from({ length: count }, (_, idx) => values.get(idx));
+  });
+
+  /**
+   * Start a function call the way Modal's clients do: a unary call sends its
+   * input with `FunctionMap` (or with `FunctionPutInputs` when Modal doesn't
+   * take it there); a map creates the call, then sends every input with
+   * `FunctionPutInputs`.
+   */
+  const start = Effect.fn(function* (
+    inputs: ReadonlyArray<readonly [ReadonlyArray<unknown>, Record<string, unknown>]>,
+    type: "FUNCTION_CALL_TYPE_UNARY" | "FUNCTION_CALL_TYPE_MAP",
+    invocation: "FUNCTION_CALL_INVOCATION_TYPE_SYNC" | "FUNCTION_CALL_INVOCATION_TYPE_ASYNC",
+  ) {
+    const id = yield* functionId;
+    const items = yield* Effect.forEach(inputs, ([args, kwargs], idx) =>
+      Effect.map(encodeInput(ops.blobs, args, kwargs, method), (input) => ({ idx, input })),
+    );
+    const unary = type === "FUNCTION_CALL_TYPE_UNARY";
+    const response = yield* ops.map({
+      functionId: id,
+      functionCallType: type,
+      functionCallInvocationType: invocation,
+      returnExceptions: false,
+      pipelinedInputs: unary ? items : undefined,
+    });
+    const functionCallId = response.functionCallId ?? "";
+    const sent = unary && (response.pipelinedInputs ?? []).length > 0 ? items.length : 0;
+    for (let offset = sent; offset < items.length; offset += BATCH) {
+      yield* ops.putInputs({
+        functionId: id,
+        functionCallId,
+        inputs: items.slice(offset, offset + BATCH),
+      });
+    }
+    return functionCallId;
+  });
+
+  return {
+    call: <A>(
+      args: ReadonlyArray<unknown> = [],
+      kwargs: Record<string, unknown> = {},
+      options: CallOptions = {},
+    ) =>
+      start(
+        [[args, kwargs]],
+        "FUNCTION_CALL_TYPE_UNARY",
+        "FUNCTION_CALL_INVOCATION_TYPE_SYNC",
+      ).pipe(
+        Effect.flatMap((id) => collect(id, 1, options.timeout)),
+        // CBOR results are untyped; the caller names the shape it expects.
+        Effect.map(([value]) => value as A),
+      ),
+    map: <A>(inputs: ReadonlyArray<ReadonlyArray<unknown>>, options: CallOptions = {}) =>
+      inputs.length === 0
+        ? Effect.succeed([] as A[])
+        : start(
+            inputs.map((args) => [args, {}] as const),
+            "FUNCTION_CALL_TYPE_MAP",
+            "FUNCTION_CALL_INVOCATION_TYPE_SYNC",
+          ).pipe(
+            Effect.flatMap((id) => collect(id, inputs.length, options.timeout)),
+            Effect.map((values) => values as A[]),
+          ),
+    spawn: (args = [], kwargs = {}) =>
+      start(
+        [[args, kwargs]],
+        "FUNCTION_CALL_TYPE_UNARY",
+        "FUNCTION_CALL_INVOCATION_TYPE_ASYNC",
+      ).pipe(Effect.map((functionCallId) => ({ functionCallId }))),
+    result: <A>(call: { readonly functionCallId: string }, options: CallOptions = {}) =>
+      collect(call.functionCallId, 1, options.timeout).pipe(Effect.map(([value]) => value as A)),
+    cancel: (call) =>
+      ops.cancel({ functionCallId: call.functionCallId }).pipe(
+        Effect.catchTag("FunctionCallNotFound", () => Effect.void),
+        Effect.asVoid,
+      ),
+  };
+};
+
+/** Whether a call's result is a streamed RPC result (see `RPC_STREAM_KEY`). */
+const isStreamResult = (value: unknown): value is { [RPC_STREAM_KEY]: unknown[] } =>
+  typeof value === "object" &&
+  value !== null &&
+  Array.isArray((value as Record<string, unknown>)[RPC_STREAM_KEY]);
+
+/**
+ * The typed client of a `Modal.Function` program's RPC methods. Each method
+ * is a call to the function's method of that name; its result is the
+ * program's JSON answer, a failure envelope the call fails with, or a
+ * stream's values. A Function without methods (an async program) keeps
+ * the {@link FunctionClient} operations.
+ */
+export const makeRpcClient = (
+  resolved: ResolvedFunction,
+  ops: InvokeOps,
+  methods: Effect.Effect<ReadonlyArray<string> | undefined>,
+  key: Effect.Effect<string | undefined>,
+): Record<string, unknown> => {
+  const client = makeFunctionClient(resolved, ops);
+  const callMethod = (name: string, args: ReadonlyArray<unknown>) =>
+    key.pipe(
+      Effect.flatMap((value) =>
+        makeFunctionClient({ ...resolved, method: name }, ops).call(
+          args,
+          // The binding's key: the program serves only callers it issued keys to.
+          value === undefined ? {} : { [RPC_KEY_KWARG]: value },
+        ),
+      ),
+      Effect.flatMap((value) =>
+        isStreamResult(value)
+          ? // The stream's values, re-encoded as the NDJSON the RPC codec
+            // decodes (byte chunks and a trailing failure marker included).
+            Effect.succeed(
+              Stream.fromIterable(value[RPC_STREAM_KEY]).pipe(
+                Stream.map((item) => `${JSON.stringify(item)}\n`),
+                Stream.encodeText,
+                decodeRpcResponseStream,
+              ),
+            )
+          : decodeRpcResult(value),
+      ),
+    );
+  return new Proxy(
+    {},
+    {
+      get: (_, prop) => {
+        // Never thenable, and no symbol members.
+        if (typeof prop !== "string" || prop === "then") return undefined;
+        const call = (args: unknown[]) =>
+          Effect.gen(function* () {
+            const names = (yield* methods) ?? [];
+            if (names.includes(prop)) return yield* callMethod(prop, args);
+            const operation = (client as unknown as Record<string, unknown>)[prop];
+            if (typeof operation === "function") {
+              return yield* (operation as (...a: unknown[]) => Effect.Effect<unknown, unknown>)(
+                ...args,
+              );
+            }
+            return yield* new RpcCallError({
+              method: prop,
+              cause: `The function has no RPC method ${prop}`,
+            });
+          });
+        return (...args: unknown[]) =>
+          asEffectOrStream(
+            // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- the stub's declared method types carry `RuntimeContext`, which the caller's runtime provides
+            call(args) as Effect.Effect<unknown, unknown>,
+          );
+      },
+    },
+  );
+};
+
+/**
+ * {@link InvokeFunction} over Modal's API. Grants the host's identity (a scoped
+ * `Modal.ServiceUser`) the `contributor` role on the function's environment.
+ *
+ * @layer
+ * @product Function
+ * @provides Modal.InvokeFunction
+ */
+export const InvokeFunctionHttp = Layer.effect(
+  InvokeFunction,
+  Effect.gen(function* () {
+    const caller = yield* RpcCaller;
+    return yield* makeFunctionBinding({
+      tag: "Modal.InvokeFunction",
+      operations: InvokeOps,
+      role: "contributor",
+      make: Effect.fn(function* (resolved, ops, target: FunctionTarget) {
+        if (isFunctionRef(target)) return makeFunctionClient(resolved, ops);
+        // This host's key for the Function's RPC methods (minted at deploy).
+        const key = yield* caller(target as unknown as { readonly LogicalId: string });
+        // The program's methods, recorded at deploy (an attribute of the Function).
+        const methods = yield* (
+          target as unknown as {
+            readonly methods: Effect.Effect<Effect.Effect<ReadonlyArray<string> | undefined>>;
+          }
+        ).methods;
+        // Typed by `InvokeFunction`'s call signatures from the target's program.
+        return makeRpcClient(resolved, ops, methods, key) as unknown as FunctionClient;
+      }),
+    });
+  }),
+);