@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-d076mabj.js

@@ -0,0 +1,683 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/aisdk.ts
+var exports_aisdk = {};
+__export(exports_aisdk, {
+  node: () => node,
+  locationLayer: () => locationLayer,
+  Service: () => Service,
+  InitError: () => InitError,
+  AISDK: () => exports_aisdk
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { APICallError } from "@ai-sdk/provider";
+import {
+  InvalidProviderOutputReason,
+  LLMEvent,
+  AIError,
+  LanguageModel,
+  ProviderID,
+  ProviderMetadata,
+  TransportReason,
+  ToolResultValue,
+  UnknownProviderReason
+} from "@opencode-ai/ai";
+import { Auth, Endpoint, RequestExecutor } from "@opencode-ai/ai/route";
+import { ProviderShared } from "@opencode-ai/ai/protocols/shared";
+import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream } from "effect";
+function wrapSSE(res, ms, ctl) {
+  if (typeof ms !== "number" || ms <= 0)
+    return res;
+  if (!res.body)
+    return res;
+  if (!res.headers.get("content-type")?.includes("text/event-stream"))
+    return res;
+  const reader = res.body.getReader();
+  const body = new ReadableStream({
+    async pull(ctrl) {
+      const part = await new Promise((resolve, reject) => {
+        const id = setTimeout(() => {
+          const err = new Error("SSE read timed out");
+          ctl.abort(err);
+          reader.cancel(err);
+          reject(err);
+        }, ms);
+        reader.read().then((part2) => {
+          clearTimeout(id);
+          resolve(part2);
+        }, (err) => {
+          clearTimeout(id);
+          reject(err);
+        });
+      });
+      if (part.done) {
+        ctrl.close();
+        return;
+      }
+      ctrl.enqueue(part.value);
+    },
+    async cancel(reason) {
+      ctl.abort(reason);
+      await reader.cancel(reason);
+    }
+  });
+  return new Response(body, {
+    headers: new Headers(res.headers),
+    status: res.status,
+    statusText: res.statusText
+  });
+}
+function prepareOptions(model, pkg) {
+  const projected = mapBodyToProviderOptions(model, pkg);
+  const options = {
+    name: model.providerID,
+    ...model.settings ?? {},
+    headers: model.headers,
+    body: projected.body
+  };
+  const customFetch = options.fetch;
+  const chunkTimeout = options.chunkTimeout;
+  delete options.chunkTimeout;
+  options.fetch = async (input, init) => {
+    const opts = { ...init ?? {} };
+    const signals = [
+      opts.signal,
+      typeof chunkTimeout === "number" && chunkTimeout > 0 ? new AbortController : undefined,
+      options.timeout !== undefined && options.timeout !== null && options.timeout !== false ? AbortSignal.timeout(options.timeout) : undefined
+    ].filter((item) => Boolean(item));
+    const chunkAbortCtl = signals.find((item) => item instanceof AbortController);
+    const abortSignals = signals.map((item) => item instanceof AbortController ? item.signal : item);
+    if (abortSignals.length === 1)
+      opts.signal = abortSignals[0];
+    if (abortSignals.length > 1)
+      opts.signal = AbortSignal.any(abortSignals);
+    if ((pkg === "@ai-sdk/openai" || pkg === "@ai-sdk/azure" || pkg === "@ai-sdk/amazon-bedrock/mantle") && opts.body && opts.method === "POST") {
+      const body = JSON.parse(opts.body);
+      if (body.store !== true && Array.isArray(body.input)) {
+        for (const item of body.input) {
+          if ("id" in item)
+            delete item.id;
+        }
+        opts.body = JSON.stringify(body);
+      }
+    }
+    if (typeof opts.body === "string" && model.body !== undefined) {
+      const decoded = Option.getOrUndefined(Schema.decodeUnknownOption(Schema.UnknownFromJsonString)(opts.body));
+      if (Schema.is(Schema.Record(Schema.String, Schema.Json))(decoded)) {
+        opts.body = JSON.stringify(exports_provider.mergeOverlay(decoded, model.body));
+      }
+    }
+    const res = await (typeof customFetch === "function" ? customFetch : fetch)(input, {
+      ...opts,
+      timeout: false
+    });
+    if (!chunkAbortCtl || typeof chunkTimeout !== "number")
+      return res;
+    return wrapSSE(res, chunkTimeout, chunkAbortCtl);
+  };
+  return options;
+}
+
+class InitError extends Schema.TaggedErrorClass()("AISDK.InitError", {
+  providerID: exports_provider.ID,
+  cause: Schema.Defect()
+}) {
+}
+function initError(providerID) {
+  return Effect.catchCause((cause) => Effect.fail(new InitError({ providerID, cause: Cause.squash(cause) })));
+}
+
+class Service extends Context.Service()("@opencode/AISDK") {
+}
+var locationLayer = Layer.effect(Service, Effect.gen(function* () {
+  let sdkHooks = [];
+  let languageHooks = [];
+  const languages = new Map;
+  const sdks = new Map;
+  const functionIDs = new WeakMap;
+  let nextFunctionID = 0;
+  const cacheKey = (input) => JSON.stringify(input, (_key, value) => {
+    if (typeof value !== "function")
+      return value;
+    const existing = functionIDs.get(value);
+    if (existing !== undefined)
+      return `function:${existing}`;
+    const id = nextFunctionID++;
+    functionIDs.set(value, id);
+    return `function:${id}`;
+  }) ?? "";
+  const register = (hooks, update) => Effect.fn("AISDK.hook")(function* (callback) {
+    const scope = yield* Scope.Scope;
+    let active = true;
+    update([...hooks(), callback]);
+    const dispose = Effect.sync(() => {
+      if (!active)
+        return;
+      active = false;
+      update(hooks().filter((item) => item !== callback));
+    });
+    yield* Scope.addFinalizer(scope, dispose);
+    return { dispose };
+  });
+  const run = Effect.fnUntraced(function* (hooks, event) {
+    for (const hook of hooks) {
+      const result = hook(event);
+      if (Effect.isEffect(result))
+        yield* result;
+    }
+    return event;
+  });
+  const service = Service.of({
+    hook: {
+      sdk: register(() => sdkHooks, (next) => sdkHooks = next),
+      language: register(() => languageHooks, (next) => languageHooks = next)
+    },
+    runSDK: (event) => run(sdkHooks, event),
+    runLanguage: (event) => run(languageHooks, event),
+    language: Effect.fn("AISDK.language")(function* (model) {
+      const key = cacheKey({
+        providerID: model.providerID,
+        id: model.id,
+        modelID: model.modelID,
+        package: model.package,
+        settings: model.settings,
+        headers: model.headers,
+        body: model.body,
+        limit: model.limit
+      });
+      const existing = languages.get(key);
+      if (existing)
+        return existing;
+      if (!exports_provider.isAISDK(model.package))
+        return yield* new InitError({
+          providerID: model.providerID,
+          cause: new Error(`Unsupported package ${model.package}`)
+        });
+      const packageName = exports_provider.packageName(model.package);
+      const options = prepareOptions(model, packageName);
+      const sdkKey = cacheKey({
+        providerID: model.providerID,
+        package: packageName,
+        settings: model.settings,
+        headers: model.headers,
+        body: model.body
+      });
+      const sdk = sdks.get(sdkKey) ?? (yield* service.runSDK({ model, package: packageName, options }).pipe(initError(model.providerID))).sdk;
+      if (!sdk)
+        return yield* new InitError({
+          providerID: model.providerID,
+          cause: new Error("No AISDK provider plugin returned an SDK")
+        });
+      sdks.set(sdkKey, sdk);
+      const result = yield* service.runLanguage({ model, sdk, options }).pipe(initError(model.providerID));
+      const language = yield* Effect.sync(() => result.language ?? sdk.languageModel(model.modelID ?? model.id)).pipe(initError(model.providerID));
+      languages.set(key, language);
+      return language;
+    }),
+    model: Effect.fn("AISDK.model")(function* (model) {
+      return modelFromLanguage(model, yield* service.language(model));
+    })
+  });
+  return service;
+}));
+function modelFromLanguage(info, language) {
+  const packageName = exports_provider.packageName(info.package);
+  const projected = mapBodyToProviderOptions(info, packageName);
+  const optionKey = providerOptionKey(packageName, info.providerID);
+  const providerOptions = (() => {
+    if (projected.settings === undefined)
+      return;
+    if (packageName === "@ai-sdk/gateway")
+      return gatewayProviderOptions(info.modelID ?? info.id, projected.settings);
+    if (packageName === "@ai-sdk/azure")
+      return { openai: projected.settings, azure: projected.settings };
+    return { [optionKey]: projected.settings };
+  })();
+  const route = {
+    id: `ai-sdk:${packageName}`,
+    provider: ProviderID.make(info.providerID),
+    providerMetadataKey: optionKey,
+    protocol: "ai-sdk",
+    endpoint: Endpoint.path("/", { baseURL: "https://ai-sdk.local" }),
+    auth: Auth.none,
+    transport: {
+      id: "ai-sdk",
+      prepare: (input) => Effect.succeed(input.body),
+      frames: () => Stream.empty
+    },
+    defaults: {
+      headers: info.headers,
+      http: projected.body === undefined && info.headers === undefined ? undefined : {
+        body: projected.body === undefined ? undefined : { ...projected.body },
+        headers: info.headers
+      },
+      limits: { context: info.limit.context, input: info.limit.input, output: info.limit.output },
+      providerOptions
+    },
+    body: {
+      schema: Schema.Unknown,
+      from: (request) => Effect.succeed(callOptions(request))
+    },
+    with: () => route,
+    model: (input) => LanguageModel.make({ ...input, provider: "provider" in input ? input.provider : info.providerID, route }),
+    prepareTransport: (body) => Effect.succeed(body),
+    streamPrepared: (prepared) => streamLanguage(language, prepared)
+  };
+  return LanguageModel.make({
+    id: info.modelID ?? info.id,
+    provider: info.providerID,
+    route,
+    compatibility: info.compatibility
+  });
+}
+function gatewayProviderOptions(modelID, settings) {
+  const gateway = typeof settings.gateway === "object" && settings.gateway !== null && !Array.isArray(settings.gateway) ? Object.fromEntries(Object.entries(settings.gateway)) : undefined;
+  const model = Object.fromEntries(Object.entries(settings).filter(([key]) => key !== "gateway"));
+  if (Object.keys(model).length === 0)
+    return gateway === undefined ? undefined : { gateway };
+  const separator = modelID.indexOf("/");
+  const prefix = separator > 0 ? modelID.slice(0, separator) : undefined;
+  if (prefix)
+    return { ...gateway === undefined ? {} : { gateway }, [prefix === "amazon" ? "bedrock" : prefix]: model };
+  if (typeof gateway === "object" && gateway !== null && !Array.isArray(gateway))
+    return { gateway: { ...gateway, ...model } };
+  return { gateway: model };
+}
+function providerOptionKey(packageName, providerID) {
+  if (packageName === "@ai-sdk/google")
+    return "google";
+  if (packageName === "@ai-sdk/google-vertex")
+    return "vertex";
+  if (packageName === "@ai-sdk/google-vertex/anthropic")
+    return "anthropic";
+  if (packageName === "@ai-sdk/amazon-bedrock")
+    return "bedrock";
+  if (packageName === "@ai-sdk/amazon-bedrock/mantle")
+    return "openai";
+  if (packageName === "@ai-sdk/azure")
+    return "azure";
+  if (packageName === "@ai-sdk/github-copilot")
+    return "copilot";
+  if (packageName === "@jerome-benoit/sap-ai-provider-v2")
+    return "sap-ai";
+  if (packageName === "@ai-sdk/openai-compatible")
+    return providerID.split(".")[0];
+  if (packageName === "@openrouter/ai-sdk-provider")
+    return "openrouter";
+  if (packageName === "ai-gateway-provider")
+    return "openaiCompatible";
+  if (packageName?.startsWith("@ai-sdk/"))
+    return packageName.slice("@ai-sdk/".length);
+  return providerID;
+}
+function requestSettings(settings) {
+  if (settings === undefined)
+    return;
+  const result = Object.fromEntries(Object.entries(settings).filter(([key]) => !["apiKey", "authToken", "baseURL", "chunkTimeout", "fetch", "timeout"].includes(key)));
+  return Object.keys(result).length === 0 ? undefined : result;
+}
+function mapBodyToProviderOptions(model, packageName) {
+  const settings = requestSettings(model.settings);
+  const pro = Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(model.body?.reasoning);
+  const forceReasoning = ["@ai-sdk/openai", "@ai-sdk/azure", "@ai-sdk/amazon-bedrock/mantle"].includes(packageName) && (pro || settings?.reasoningEffort !== undefined || settings?.reasoningSummary !== undefined);
+  const normalized = forceReasoning ? exports_provider.mergeOverlay(settings, { forceReasoning: true }) : settings;
+  if (!pro)
+    return { settings: normalized, body: model.body };
+  const body = { ...model.body };
+  delete body.reasoning;
+  return {
+    settings: exports_provider.mergeOverlay(normalized, { reasoningMode: "pro" }),
+    body: Object.keys(body).length === 0 ? undefined : body
+  };
+}
+function callOptions(request) {
+  return {
+    prompt: prompt(request),
+    maxOutputTokens: request.generation?.maxTokens,
+    temperature: request.generation?.temperature,
+    stopSequences: request.generation?.stop === undefined ? undefined : [...request.generation.stop],
+    topP: request.generation?.topP,
+    topK: request.generation?.topK,
+    presencePenalty: request.generation?.presencePenalty,
+    frequencyPenalty: request.generation?.frequencyPenalty,
+    seed: request.generation?.seed,
+    tools: request.tools.map(tool),
+    toolChoice: toolChoice(request.toolChoice),
+    headers: request.http?.headers,
+    providerOptions: providerOptions(request.providerOptions)
+  };
+}
+function prompt(request) {
+  const system = request.system.map((part) => part.text).filter(Boolean).join(`
+
+`);
+  const messages = request.messages.flatMap(message);
+  if (!system.length)
+    return messages;
+  return [{ role: "system", content: system }, ...messages];
+}
+function message(input) {
+  switch (input.role) {
+    case "system":
+      return [{ role: "system", content: input.content.flatMap(text).join(`
+
+`) }];
+    case "user":
+      return [{ role: "user", content: input.content.flatMap(userPart) }];
+    case "assistant":
+      return [{ role: "assistant", content: input.content.flatMap(assistantPart) }];
+    case "tool": {
+      const content = input.content.flatMap(toolResultPart);
+      return content.length ? [{ role: "tool", content }] : [];
+    }
+  }
+}
+function text(part) {
+  return part.type === "text" ? [part.text] : [];
+}
+function userPart(part) {
+  if (part.type === "text")
+    return [{ type: "text", text: part.text }];
+  if (part.type === "media")
+    return [{ type: "file", mediaType: part.mediaType, data: part.data, filename: part.filename }];
+  return [];
+}
+function assistantPart(part) {
+  switch (part.type) {
+    case "text":
+      return [{ type: "text", text: part.text }];
+    case "media":
+      return [{ type: "file", mediaType: part.mediaType, data: part.data, filename: part.filename }];
+    case "reasoning":
+      return [{ type: "reasoning", text: part.text, providerOptions: providerOptions(part.providerMetadata) }];
+    case "tool-call":
+      return [
+        {
+          type: "tool-call",
+          toolCallId: part.id,
+          toolName: part.name,
+          input: part.input,
+          providerExecuted: part.providerExecuted,
+          providerOptions: providerOptions(part.providerMetadata)
+        }
+      ];
+    case "tool-result":
+      return toolResultPart(part);
+  }
+}
+function toolResultPart(part) {
+  if (part.type !== "tool-result")
+    return [];
+  return [
+    {
+      type: "tool-result",
+      toolCallId: part.id,
+      toolName: part.name,
+      output: toolOutput(part.result),
+      providerOptions: providerOptions(part.providerMetadata)
+    }
+  ];
+}
+function toolOutput(result) {
+  switch (result.type) {
+    case "text":
+    case "error":
+      return { type: "text", value: messageValue(result.value) };
+    case "content":
+      return {
+        type: "content",
+        value: result.value.map((item) => {
+          if (item.type === "text")
+            return { type: "text", text: item.text };
+          const data = /^data:[^;,]+(?:;[^,]*)*;base64,(.*)$/s.exec(item.uri)?.[1];
+          const image = item.mime.toLowerCase().startsWith("image/");
+          if (data !== undefined)
+            return image ? { type: "image-data", data, mediaType: item.mime } : { type: "file-data", data, mediaType: item.mime, filename: item.name };
+          return image ? { type: "image-url", url: item.uri } : { type: "file-url", url: item.uri };
+        })
+      };
+    case "json":
+      return { type: "json", value: jsonValue(result.value) };
+  }
+}
+function tool(input) {
+  return {
+    type: "function",
+    name: input.name,
+    description: input.description,
+    inputSchema: input.inputSchema
+  };
+}
+function toolChoice(input) {
+  if (!input)
+    return;
+  if (input.type === "tool")
+    return input.name === undefined ? undefined : { type: "tool", toolName: input.name };
+  return { type: input.type };
+}
+function providerOptions(input) {
+  if (!input)
+    return;
+  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, jsonObject(value)]));
+}
+function streamLanguage(language, options) {
+  const state = { step: 0, toolNames: {} };
+  return Stream.concat(Stream.make(LLMEvent.stepStart({ index: state.step })), Stream.unwrap(Effect.tryPromise({
+    try: () => language.doStream(options),
+    catch: (error) => llmError("doStream", error)
+  }).pipe(Effect.map((result) => Stream.fromReadableStream({
+    evaluate: () => result.stream,
+    onError: (error) => llmError("readStream", error)
+  }).pipe(Stream.mapEffect((event) => streamPartEvents(state, event)), Stream.flatMap((events) => Stream.fromIterable(events)))))));
+}
+function streamPartEvents(state, event) {
+  switch (event.type) {
+    case "stream-start":
+    case "response-metadata":
+    case "raw":
+    case "file":
+    case "source":
+    case "tool-approval-request":
+      return Effect.succeed([]);
+    case "text-start":
+      return Effect.succeed([
+        LLMEvent.textStart({ id: event.id, providerMetadata: providerMetadata(event.providerMetadata) })
+      ]);
+    case "text-delta":
+      return Effect.succeed([
+        LLMEvent.textDelta({
+          id: event.id,
+          text: event.delta,
+          providerMetadata: providerMetadata(event.providerMetadata)
+        })
+      ]);
+    case "text-end":
+      return Effect.succeed([
+        LLMEvent.textEnd({ id: event.id, providerMetadata: providerMetadata(event.providerMetadata) })
+      ]);
+    case "reasoning-start":
+      return Effect.succeed([
+        LLMEvent.reasoningStart({ id: event.id, providerMetadata: providerMetadata(event.providerMetadata) })
+      ]);
+    case "reasoning-delta":
+      return Effect.succeed([
+        LLMEvent.reasoningDelta({
+          id: event.id,
+          text: event.delta,
+          providerMetadata: providerMetadata(event.providerMetadata)
+        })
+      ]);
+    case "reasoning-end":
+      return Effect.succeed([
+        LLMEvent.reasoningEnd({ id: event.id, providerMetadata: providerMetadata(event.providerMetadata) })
+      ]);
+    case "tool-input-start":
+      state.toolNames[event.id] = event.toolName;
+      return Effect.succeed([
+        LLMEvent.toolInputStart({
+          id: event.id,
+          name: event.toolName,
+          providerExecuted: event.providerExecuted,
+          providerMetadata: providerMetadata(event.providerMetadata)
+        })
+      ]);
+    case "tool-input-delta":
+      return Effect.succeed([
+        LLMEvent.toolInputDelta({ id: event.id, name: state.toolNames[event.id] ?? "unknown", text: event.delta })
+      ]);
+    case "tool-input-end":
+      return Effect.succeed([
+        LLMEvent.toolInputEnd({
+          id: event.id,
+          name: state.toolNames[event.id] ?? "unknown",
+          providerMetadata: providerMetadata(event.providerMetadata)
+        })
+      ]);
+    case "tool-call":
+      state.toolNames[event.toolCallId] = event.toolName;
+      return ProviderShared.parseToolInput("aisdk", event.toolName, event.input).pipe(Effect.map((input) => [
+        LLMEvent.toolCall({
+          id: event.toolCallId,
+          name: event.toolName,
+          input,
+          providerExecuted: event.providerExecuted,
+          providerMetadata: providerMetadata(event.providerMetadata)
+        })
+      ]), Effect.catch((error) => event.providerExecuted ? Effect.fail(error) : Effect.succeed([
+        LLMEvent.toolInputError({
+          id: event.toolCallId,
+          name: event.toolName,
+          raw: event.input
+        })
+      ])));
+    case "tool-result":
+      delete state.toolNames[event.toolCallId];
+      return Effect.succeed([
+        LLMEvent.toolResult({
+          id: event.toolCallId,
+          name: event.toolName,
+          result: ToolResultValue.make(event.result, event.isError ? "error" : "json"),
+          providerExecuted: true,
+          providerMetadata: providerMetadata(event.providerMetadata)
+        })
+      ]);
+    case "finish":
+      return Effect.succeed([
+        LLMEvent.stepFinish({
+          index: state.step++,
+          reason: { normalized: finishReason(event.finishReason), raw: event.finishReason.raw },
+          usage: usage(event.usage),
+          providerMetadata: providerMetadata(event.providerMetadata)
+        }),
+        LLMEvent.finish({
+          reason: { normalized: finishReason(event.finishReason), raw: event.finishReason.raw },
+          usage: usage(event.usage),
+          providerMetadata: providerMetadata(event.providerMetadata)
+        })
+      ]);
+    case "error":
+      return Effect.fail(llmError("stream", event.error));
+  }
+}
+function usage(input) {
+  const output = {
+    inputTokens: input.inputTokens.total,
+    nonCachedInputTokens: input.inputTokens.noCache,
+    cacheReadInputTokens: input.inputTokens.cacheRead,
+    cacheWriteInputTokens: input.inputTokens.cacheWrite,
+    outputTokens: input.outputTokens.total,
+    reasoningTokens: input.outputTokens.reasoning,
+    totalTokens: input.inputTokens.total === undefined || input.outputTokens.total === undefined ? undefined : input.inputTokens.total + input.outputTokens.total
+  };
+  return Object.values(output).some((value) => value !== undefined) ? output : undefined;
+}
+function finishReason(value) {
+  return value.unified === "other" ? "unknown" : value.unified;
+}
+function providerMetadata(value) {
+  return Schema.is(ProviderMetadata)(value) ? value : undefined;
+}
+function jsonObject(input) {
+  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, jsonValue(value)]));
+}
+function jsonValue(input) {
+  try {
+    const encoded = JSON.stringify(input);
+    return encoded === undefined ? null : JSON.parse(encoded);
+  } catch {
+    return messageValue(input);
+  }
+}
+function messageValue(input) {
+  if (typeof input === "string")
+    return input;
+  try {
+    return JSON.stringify(input) ?? String(input);
+  } catch {
+    return String(input);
+  }
+}
+function llmError(method, error) {
+  const reason = error instanceof AIError ? new InvalidProviderOutputReason({ message: error.message }) : APICallError.isInstance(error) ? apiCallErrorReason(error) : new UnknownProviderReason({ message: unknownErrorMessage(error) });
+  return new AIError({
+    module: "AISDK",
+    method,
+    reason
+  });
+}
+function apiCallErrorReason(error) {
+  const details = providerErrorDetails(error);
+  const reason = RequestExecutor.classifyHttpFailure({
+    message: details.message,
+    url: error.url,
+    status: error.statusCode,
+    code: details.code,
+    responseHeaders: error.responseHeaders,
+    responseBody: error.responseBody
+  });
+  if (error.statusCode !== undefined || !error.isRetryable)
+    return reason;
+  return new TransportReason({
+    message: reason.message,
+    transport: "http",
+    operation: "request",
+    code: error.name,
+    url: error.url,
+    http: "http" in reason ? reason.http : undefined
+  });
+}
+var ProviderErrorCode = Schema.Union([Schema.String, Schema.Finite]);
+var ProviderErrorDetail = Schema.Struct({
+  message: Schema.optionalKey(Schema.String),
+  code: Schema.optionalKey(ProviderErrorCode)
+});
+var ProviderErrorBody = Schema.Struct({
+  ...ProviderErrorDetail.fields,
+  error: Schema.optionalKey(ProviderErrorDetail)
+});
+var decodeProviderError = Schema.decodeUnknownOption(Schema.Union([ProviderErrorBody, Schema.fromJsonString(ProviderErrorBody)]));
+function unknownErrorMessage(error) {
+  const message2 = error instanceof Error ? error.message : String(error);
+  return message2.trim() === "" ? "Provider request failed" : message2;
+}
+function providerErrorDetails(error) {
+  const data = Option.getOrUndefined(decodeProviderError(error.data));
+  const body = Option.getOrUndefined(decodeProviderError(error.responseBody));
+  const details = [data?.error, data, body?.error, body];
+  const message2 = details.map((detail) => detail?.message).find((value2) => value2?.trim());
+  const value = details.map((detail) => detail?.code).find((value2) => value2 !== undefined);
+  const code = value === undefined ? undefined : String(value);
+  const prefix = error.statusCode === undefined ? "Provider request failed" : `Provider request failed with HTTP ${error.statusCode}`;
+  return {
+    code,
+    message: error.message.trim() !== "" ? error.message : message2 ?? (code === undefined ? prefix : `${prefix}: ${code}`)
+  };
+}
+var node = makeLocationNode({ service: Service, layer: locationLayer, deps: [] });
+
+export { InitError, Service, locationLayer, node, exports_aisdk };