@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-spc2jgzw.js

@@ -0,0 +1,271 @@
+import {
+  exports_parse
+} from "./permission-7mpw7j43.js";
+import {
+  exports_tool_output
+} from "./permission-6xc82ex6.js";
+import {
+  exports_runtime
+} from "./permission-h487ttse.js";
+import {
+  exports_shell
+} from "./permission-qde5933h.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  exports_location_mutation
+} from "./permission-a2yyszsy.js";
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  NonNegativeInt
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/plugin/shell.ts
+var exports_shell2 = {};
+__export(exports_shell2, {
+  name: () => name,
+  ShellTool: () => exports_shell2,
+  Plugin: () => Plugin,
+  Input: () => Input,
+  DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS
+});
+import path from "path";
+import { ToolFailure } from "@opencode-ai/ai";
+import { Deferred, Effect, Schema, Scope } from "effect";
+var name = "shell";
+var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
+var BACKGROUND_STARTED = "The command was moved to the background.";
+var BACKGROUND_INSTRUCTION = "You will be notified automatically when the command finishes. DO NOT sleep, poll, or proactively check on its progress.";
+var OS = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : process.platform === "linux" ? "Linux" : process.platform;
+var description = (shell) => [
+  "Execute a shell command and return its output.",
+  ...shell ? [`Commands run on ${OS} using ${shell}.`] : [],
+  "Quote file paths containing spaces or special characters.",
+  "Prefer dedicated tools over shell commands when possible.",
+  "When output is large, the full result is saved to a file and a truncated preview is returned.",
+  "Rely on automatic truncation unless filtering the output is more useful.",
+  "Commands accept an optional timeout, background commands have no timeout by default.",
+  "Background commands return immediately, and you will be notified when they complete."
+].join(" ");
+var Input = Schema.Struct({
+  command: Schema.String.annotate({ description: "Shell command string to execute" }),
+  workdir: Schema.optionalKey(Schema.String).annotate({
+    description: "Working directory to execute the command in. Defaults to the current working directory. When possible, avoid changing directories in the command and set the working directory here instead."
+  }),
+  timeout: Schema.optionalKey(NonNegativeInt).annotate({
+    description: `Timeout in milliseconds. Set to 0 to disable the timeout. Defaults to ${DEFAULT_TIMEOUT_MS} for foreground commands. Background commands have no timeout by default.`
+  }),
+  background: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Run the command in the background and return immediately. You will be notified when it completes. DO NOT poll its progress."
+  })
+});
+var StructuredOutput = Schema.Struct({
+  exit: Schema.optionalKey(Schema.Number),
+  shellID: Schema.optionalKey(Schema.String),
+  truncated: Schema.Boolean,
+  timeout: Schema.optionalKey(Schema.Boolean)
+});
+var Output = Schema.Struct({
+  ...StructuredOutput.fields,
+  output: Schema.String,
+  status: Schema.optionalKey(Schema.Literals(["completed", "running"]))
+});
+var modelOutput = (output) => {
+  if (output.status === "running")
+    return BACKGROUND_INSTRUCTION;
+  if (output.timeout)
+    return "Command timed out before completion.";
+  return `Command exited with code ${output.exit}.`;
+};
+var Plugin = {
+  id: "opencode.tool.shell",
+  effect: Effect.fn("ShellTool.Plugin")(function* (ctx) {
+    const runtime = yield* exports_runtime.Service;
+    const scope = yield* Scope.Scope;
+    const environment = yield* exports_environment.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const shell = yield* exports_shell.Service;
+    const permission = yield* exports_permission.Service;
+    const config = yield* exports_config.Service;
+    const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (sessionID, id, command) {
+      yield* runtime.job.wait({ id }).pipe(Effect.flatMap((result) => {
+        const state = result.info?.status === "completed" ? "completed" : result.info?.status === "error" ? "error" : result.info?.status === "cancelled" ? "cancelled" : undefined;
+        if (state === undefined)
+          return Effect.void;
+        const text = state === "completed" ? result.info.output ?? "" : state === "error" ? result.info.error ?? "Command failed" : "Command cancelled";
+        return runtime.session.synthetic({
+          sessionID,
+          text: `<shell id="${id}" state="${state}" command="${command}">
+${text}
+</shell>`,
+          description: command,
+          metadata: { source: "shell", state }
+        });
+      }), Effect.forkIn(scope, { startImmediately: true }));
+    });
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description: description(),
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = {
+          type: "tool",
+          messageID: context.messageID,
+          id: context.id
+        };
+        const timeout = input.background === true ? input.timeout ?? 0 : input.timeout ?? DEFAULT_TIMEOUT_MS;
+        let finalTimeout = timeout;
+        const info = yield* shell.create({
+          command: input.command,
+          cwd: input.workdir,
+          timeout,
+          metadata: { sessionID: context.sessionID }
+        }, (invocation) => Effect.gen(function* () {
+          const target = yield* mutation.resolve({ path: invocation.cwd, kind: "directory" });
+          const parsed = yield* exports_parse.scan(invocation.command, invocation.shell, target.absolute);
+          const directories = yield* Effect.forEach(parsed.directories, (directory) => mutation.resolve({ path: path.resolve(target.absolute, directory), kind: "directory" }));
+          invocation.cwd = target.absolute;
+          finalTimeout = invocation.timeout;
+          const external = [target, ...directories].map((item) => item.externalDirectory).filter((item) => item !== undefined).filter((item, index, items) => items.findIndex((other) => other.resource === item.resource) === index);
+          if (external.length > 0)
+            yield* permission.assert({
+              action: "external_directory",
+              resources: external.map((item) => item.resource),
+              save: external.map((item) => item.save),
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source
+            });
+          if (parsed.commands.length > 0)
+            yield* permission.assert({
+              action: name,
+              resources: parsed.commands.map((command) => command.resource),
+              save: parsed.commands.map((command) => command.save),
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source
+            });
+          const workdir = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new Error(`Working directory does not exist: ${target.absolute}`))));
+          if (workdir !== "directory")
+            return yield* Effect.fail(new Error(`Working directory is not a directory: ${target.absolute}`));
+        }));
+        yield* context.progress({ shellID: info.id });
+        const captureShell = Effect.fn("ShellTool.captureShell")(function* () {
+          const configured = exports_config.latest(yield* config.entries(), "tool_output");
+          const maxLines = configured?.max_lines ?? exports_tool_output.MAX_LINES;
+          const maxBytes = configured?.max_bytes ?? exports_tool_output.MAX_BYTES;
+          const latest = yield* shell.output(info.id, { cursor: Number.MAX_SAFE_INTEGER });
+          const page = yield* shell.output(info.id, {
+            cursor: Math.max(0, latest.size - maxBytes),
+            limit: maxBytes
+          });
+          const lines = page.output.split(`
+`);
+          if (page.output.endsWith(`
+`))
+            lines.pop();
+          const truncated = latest.size > maxBytes || lines.length > maxLines;
+          const output = lines.length > maxLines ? lines.slice(-maxLines).join(`
+`) : page.output;
+          const notice = truncated ? `
+
+[output truncated; full output saved to: ${info.file}]` : "";
+          return {
+            output: `${output || "(no output)"}${notice}`,
+            truncated
+          };
+        });
+        const settleShell = Effect.fn("ShellTool.settleShell")(function* () {
+          const final = yield* shell.wait(info.id);
+          const capture = yield* captureShell();
+          if (final.status === "timeout") {
+            return {
+              ...final.exit !== undefined ? { exit: final.exit } : {},
+              output: `${capture.output}
+
+Command exceeded timeout of ${finalTimeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
+              truncated: capture.truncated,
+              timeout: true,
+              status: "completed"
+            };
+          }
+          return {
+            ...final.exit !== undefined ? { exit: final.exit } : {},
+            output: capture.output,
+            truncated: capture.truncated,
+            status: "completed"
+          };
+        });
+        const settled = yield* Deferred.make();
+        const run = settleShell().pipe(Effect.tap((output) => Deferred.succeed(settled, output)), Effect.map((output) => output.output), Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)));
+        const job = yield* runtime.job.start({
+          id: context.id,
+          type: name,
+          title: info.command,
+          metadata: { sessionID: context.sessionID, shellID: info.id },
+          run
+        });
+        if (input.background === true) {
+          yield* runtime.job.background(job.id);
+          yield* notifyWhenDone(context.sessionID, context.id, info.command);
+          return {
+            output: BACKGROUND_STARTED,
+            shellID: info.id,
+            truncated: false,
+            status: "running"
+          };
+        }
+        const result = yield* runtime.job.block({ id: job.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)));
+        if (result?.type === "backgrounded") {
+          yield* shell.timeout(info.id, 0);
+          yield* notifyWhenDone(context.sessionID, context.id, info.command);
+          return {
+            output: BACKGROUND_STARTED,
+            shellID: info.id,
+            truncated: false,
+            status: "running"
+          };
+        }
+        if (result?.info.status === "error")
+          return yield* Effect.fail(new Error(result.info.error ?? "Command failed"));
+        if (result?.info.status === "cancelled")
+          return yield* Effect.fail(new Error("Command cancelled"));
+        return yield* Deferred.await(settled);
+      }).pipe(Effect.map((output) => {
+        const content = [{ type: "text", text: output.output }];
+        const model = modelOutput(output);
+        if (model)
+          content.push({ type: "text", text: model });
+        return {
+          output,
+          content,
+          metadata: {
+            truncated: output.truncated,
+            ..."exit" in output && output.exit !== undefined ? { exit: output.exit } : {},
+            ..."shellID" in output && output.shellID !== undefined ? { shellID: output.shellID } : {},
+            ..."timeout" in output && output.timeout !== undefined ? { timeout: output.timeout } : {}
+          }
+        };
+      }), Effect.mapError((error) => new ToolFailure({ message: `Unable to execute command: ${input.command}`, error })))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const tool = event.tools[name];
+      if (!tool)
+        return;
+      tool.description = description(yield* shell.name());
+    }));
+  })
+};
+
+export { name, DEFAULT_TIMEOUT_MS, Input, Plugin, exports_shell2 as exports_shell };

package/dist/chunks/permission-szax8zgv.js

@@ -0,0 +1,251 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/aisdk-native.ts
+var exports_aisdk_native = {};
+__export(exports_aisdk_native, {
+  map: () => map,
+  AISDKNative: () => exports_aisdk_native
+});
+import { isRecord } from "@opencode-ai/ai/utils/record";
+function map(input) {
+  const baseSettings = mapBaseSettings(input.settings);
+  switch (input.packageName) {
+    case "@ai-sdk/amazon-bedrock":
+      return {
+        package: "@opencode-ai/ai/providers/amazon-bedrock",
+        settings: mapBedrockSettings(input.settings, baseSettings),
+        ...mapBedrockRequest(input)
+      };
+    case "@ai-sdk/amazon-bedrock/mantle":
+      return mapBedrockMantle(input, baseSettings);
+    case "@ai-sdk/azure":
+      return {
+        package: `@opencode-ai/ai/providers/azure/${input.settings.useCompletionUrls === true ? "chat" : "responses"}`,
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(input.settings),
+          ...typeof input.settings.resourceName === "string" ? { resourceName: input.settings.resourceName } : {},
+          ...typeof input.settings.apiVersion === "string" ? { apiVersion: input.settings.apiVersion } : {},
+          ...isStringRecord(input.settings.queryParams) ? { queryParams: input.settings.queryParams } : {},
+          ...typeof input.settings.useDeploymentBasedUrls === "boolean" ? { useDeploymentBasedUrls: input.settings.useDeploymentBasedUrls } : {},
+          ...mapOpenAIOptions(input.settings)
+        }
+      };
+    case "@ai-sdk/google":
+      return {
+        package: "@opencode-ai/ai/providers/google",
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(input.settings),
+          ...mapGoogleOptions(input.settings)
+        }
+      };
+    case "@ai-sdk/google-vertex/anthropic":
+      return {
+        package: "@opencode-ai/ai/providers/google-vertex/messages",
+        settings: {
+          ...baseSettings,
+          ...typeof input.settings.accessToken === "string" ? { accessToken: input.settings.accessToken } : {},
+          ...typeof input.settings.location === "string" ? { location: input.settings.location } : {},
+          ...typeof input.settings.project === "string" ? { project: input.settings.project } : {},
+          ...isRecord(input.settings.thinking) || typeof input.settings.effort === "string" ? {
+            providerOptions: {
+              anthropic: {
+                ...isRecord(input.settings.thinking) ? { thinking: input.settings.thinking } : {},
+                ...typeof input.settings.effort === "string" ? { effort: input.settings.effort } : {}
+              }
+            }
+          } : {}
+        },
+        ...isStringRecord(input.settings.headers) ? { headers: input.settings.headers } : {}
+      };
+    case "@openrouter/ai-sdk-provider":
+      return mapOpenRouter(input.settings, baseSettings);
+    case "@ai-sdk/xai":
+      return {
+        package: "@opencode-ai/ai/providers/xai",
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(input.settings),
+          ...mapXAIOptions(input.settings)
+        }
+      };
+  }
+}
+function mapBedrockMantle(input, baseSettings) {
+  const settings = input.settings;
+  const chat = input.modelID === "openai.gpt-oss-safeguard-20b" || input.modelID === "openai.gpt-oss-safeguard-120b";
+  return {
+    package: `@opencode-ai/ai/providers/amazon-bedrock/mantle/${chat ? "chat" : "responses"}`,
+    settings: {
+      ...mapBedrockSettings(settings, baseSettings),
+      ...mapOpenAIOptions(settings)
+    },
+    ...isStringRecord(settings.headers) ? { headers: settings.headers } : {}
+  };
+}
+function mapBedrockSettings(settings, baseSettings) {
+  const apiKey = typeof settings.apiKey === "string" ? settings.apiKey : typeof settings.bearerToken === "string" ? settings.bearerToken : undefined;
+  const region = bedrockRegion(settings);
+  const credentials = mapBedrockCredentials(settings, region);
+  return {
+    ...baseSettings,
+    ...typeof baseSettings.baseURL === "string" && region !== undefined ? { baseURL: baseSettings.baseURL.replaceAll("${AWS_REGION}", region) } : {},
+    ...typeof settings.baseURL !== "string" && typeof settings.endpoint === "string" ? { baseURL: settings.endpoint } : {},
+    ...apiKey === undefined ? {} : { apiKey },
+    ...credentials === undefined ? {} : { credentials },
+    ...typeof settings.region === "string" ? { region: settings.region } : {},
+    ...typeof settings.topP === "number" ? { topP: settings.topP } : {}
+  };
+}
+function mapBedrockRequest(input) {
+  const settings = input.settings;
+  const headers = isStringRecord(settings.headers) ? settings.headers : undefined;
+  const additional = isRecord(settings.additionalModelRequestFields) ? settings.additionalModelRequestFields : {};
+  const reasoning = isRecord(settings.reasoningConfig) ? settings.reasoningConfig : undefined;
+  const anthropic = input.modelID.includes("anthropic");
+  const openai = input.modelID.startsWith("openai.");
+  const effort = typeof reasoning?.maxReasoningEffort === "string" ? reasoning.maxReasoningEffort : undefined;
+  const type = typeof reasoning?.type === "string" ? reasoning.type : undefined;
+  const budget = typeof reasoning?.budgetTokens === "number" ? reasoning.budgetTokens : undefined;
+  const display = typeof reasoning?.display === "string" ? reasoning.display : undefined;
+  const betas = Array.isArray(settings.anthropicBeta) ? settings.anthropicBeta.filter((item) => typeof item === "string") : [];
+  const existingBetas = Array.isArray(additional.anthropic_beta) ? additional.anthropic_beta.filter((item) => typeof item === "string") : [];
+  const fields = exports_provider.mergeOverlay(additional, {
+    ...betas.length > 0 ? { anthropic_beta: [...existingBetas, ...betas] } : {},
+    ...anthropic && type === "enabled" && budget !== undefined ? { thinking: { type: "enabled", budget_tokens: budget } } : {},
+    ...anthropic && type === "adaptive" ? { thinking: { type: "adaptive", ...display === undefined ? {} : { display } } } : {},
+    ...anthropic && effort !== undefined ? {
+      output_config: {
+        ...isRecord(additional.output_config) ? additional.output_config : {},
+        effort
+      }
+    } : {},
+    ...!anthropic && openai && effort !== undefined ? { reasoning_effort: effort } : {},
+    ...!anthropic && !openai && effort !== undefined ? {
+      reasoningConfig: {
+        ...type === undefined || type === "adaptive" ? {} : { type },
+        ...budget === undefined ? {} : { budgetTokens: budget },
+        maxReasoningEffort: effort
+      }
+    } : {}
+  });
+  const body = {
+    ...fields && Object.keys(fields).length > 0 ? { additionalModelRequestFields: fields } : {},
+    ...typeof settings.serviceTier === "string" ? { serviceTier: { type: settings.serviceTier } } : {}
+  };
+  return {
+    ...headers === undefined ? {} : { headers },
+    ...Object.keys(body).length === 0 ? {} : { body }
+  };
+}
+function mapBedrockCredentials(settings, region) {
+  const credentials = isRecord(settings.credentials) ? settings.credentials : settings;
+  if (region === undefined || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string")
+    return;
+  return {
+    region,
+    accessKeyId: credentials.accessKeyId,
+    secretAccessKey: credentials.secretAccessKey,
+    ...typeof credentials.sessionToken === "string" ? { sessionToken: credentials.sessionToken } : {}
+  };
+}
+function bedrockRegion(settings) {
+  const credentials = isRecord(settings.credentials) ? settings.credentials : settings;
+  return typeof settings.region === "string" ? settings.region : typeof credentials.region === "string" ? credentials.region : undefined;
+}
+function mapOpenAIOptions(settings) {
+  const options = {
+    ...typeof settings.reasoningEffort === "string" ? { reasoningEffort: settings.reasoningEffort } : {},
+    ...typeof settings.reasoningSummary === "string" ? { reasoningSummary: settings.reasoningSummary } : {},
+    ...Array.isArray(settings.include) ? { include: settings.include } : {},
+    ...typeof settings.store === "boolean" ? { store: settings.store } : {},
+    ...typeof settings.promptCacheKey === "string" ? { promptCacheKey: settings.promptCacheKey } : {},
+    ...typeof settings.textVerbosity === "string" ? { textVerbosity: settings.textVerbosity } : {},
+    ...typeof settings.serviceTier === "string" ? { serviceTier: settings.serviceTier } : {}
+  };
+  if (Object.keys(options).length === 0)
+    return {};
+  return { providerOptions: { openai: options } };
+}
+function mapBaseSettings(settings) {
+  return {
+    ...typeof settings.baseURL === "string" ? { baseURL: settings.baseURL } : {}
+  };
+}
+function mapAPIKey(settings) {
+  return typeof settings.apiKey === "string" ? { apiKey: settings.apiKey } : {};
+}
+function mapGoogleOptions(settings) {
+  const input = settings.thinkingConfig;
+  const thinkingConfig = {
+    ...isRecord(input) && typeof input.thinkingBudget === "number" ? { thinkingBudget: input.thinkingBudget } : {},
+    ...isRecord(input) && typeof input.includeThoughts === "boolean" ? { includeThoughts: input.includeThoughts } : {},
+    ...isRecord(input) && typeof input.thinkingLevel === "string" ? { thinkingLevel: input.thinkingLevel } : {}
+  };
+  const options = {
+    ...typeof settings.cachedContent === "string" ? { cachedContent: settings.cachedContent } : {},
+    ...Array.isArray(settings.safetySettings) ? { safetySettings: settings.safetySettings } : {},
+    ...typeof settings.serviceTier === "string" ? { serviceTier: settings.serviceTier } : {},
+    ...Object.keys(thinkingConfig).length > 0 ? { thinkingConfig } : {}
+  };
+  if (Object.keys(options).length === 0)
+    return {};
+  return { providerOptions: { gemini: options } };
+}
+function mapOpenRouter(settings, baseSettings) {
+  const headers = exports_provider.mergeHeaders({
+    ...typeof settings.appName === "string" ? { "X-OpenRouter-Title": settings.appName } : {},
+    ...typeof settings.appUrl === "string" ? { "HTTP-Referer": settings.appUrl } : {},
+    ...isStringRecord(settings.api_keys) && Object.keys(settings.api_keys).length > 0 ? { "X-Provider-API-Keys": JSON.stringify(settings.api_keys) } : {}
+  }, isStringRecord(settings.headers) ? settings.headers : undefined) ?? {};
+  return {
+    package: "@opencode-ai/ai/providers/openrouter",
+    settings: {
+      ...baseSettings,
+      ...mapAPIKey(settings),
+      ...mapOpenRouterOptions(settings)
+    },
+    ...Object.keys(headers).length > 0 ? { headers } : {},
+    ...isRecord(settings.extraBody) ? { body: settings.extraBody } : {}
+  };
+}
+function mapOpenRouterOptions(settings) {
+  const options = Object.fromEntries(Object.entries(settings).filter(([key]) => ![
+    "apiKey",
+    "api_keys",
+    "appName",
+    "appUrl",
+    "authToken",
+    "baseURL",
+    "chunkTimeout",
+    "compatibility",
+    "extraBody",
+    "fetch",
+    "headers",
+    "promptCacheKey",
+    "timeout"
+  ].includes(key)));
+  if (Object.keys(options).length === 0)
+    return {};
+  return { providerOptions: { openrouter: options } };
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+}
+function mapXAIOptions(settings) {
+  const options = {
+    ...typeof settings.reasoningEffort === "string" ? { reasoningEffort: settings.reasoningEffort } : {},
+    ...typeof settings.store === "boolean" ? { store: settings.store } : {}
+  };
+  if (Object.keys(options).length === 0)
+    return {};
+  return { providerOptions: { xai: options } };
+}
+
+export { map, exports_aisdk_native };

package/dist/chunks/permission-szjq6xea.js

@@ -0,0 +1,57 @@
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/runner/retry.ts
+var exports_retry = {};
+__export(exports_retry, {
+  schedule: () => schedule,
+  isRetryable: () => isRetryable,
+  SessionRunnerRetry: () => exports_retry,
+  RetryableFailure: () => RetryableFailure
+});
+import { Data, Duration, Effect, Schedule } from "effect";
+class RetryableFailure extends Data.TaggedError("SessionRunner.RetryableFailure") {
+}
+function isRetryable(error) {
+  switch (error.reason._tag) {
+    case "RateLimit":
+    case "ProviderInternal":
+    case "Transport":
+      return true;
+    case "InvalidProviderOutput":
+      return error.reason.classification === "incomplete-stream";
+    case "Authentication":
+    case "QuotaExceeded":
+    case "ContentPolicy":
+    case "InvalidRequest":
+    case "NoRoute":
+    case "UnknownProvider":
+      return false;
+    default: {
+      const exhaustive = error.reason;
+      return exhaustive;
+    }
+  }
+}
+var retryAfter = (failure) => {
+  if (failure.cause.reason._tag === "RateLimit" || failure.cause.reason._tag === "ProviderInternal")
+    return failure.cause.reason.retryAfterMs;
+  return;
+};
+var schedule = (bus, sessionID, assistantMessageID) => Schedule.max([Schedule.exponential("2 seconds"), Schedule.recurs(4)]).pipe(Schedule.jittered, Schedule.setInputType(), Schedule.modifyDelay(({ input: failure, duration: delay }) => {
+  const minimum = retryAfter(failure);
+  const duration = minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum));
+  return Effect.succeed(Duration.millis(Math.ceil(Duration.toMillis(duration))));
+}), Schedule.tap((metadata) => bus.publish(SessionEvent.RetryScheduled, {
+  sessionID,
+  assistantMessageID: assistantMessageID(),
+  attempt: metadata.attempt + 1,
+  at: metadata.now + Duration.toMillis(metadata.duration),
+  error: metadata.input.error
+})));
+
+export { RetryableFailure, isRetryable, schedule, exports_retry };