@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-c9wtqnwj.js

@@ -0,0 +1,814 @@
+import {
+  ID16,
+  isAISDK2,
+  packageName2,
+  mergeOverlay2
+} from "./repository-pye8sh6e.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/aisdk.ts
+var exports_aisdk = {};
+__export(exports_aisdk, {
+  AISDK: () => exports_aisdk,
+  InitError: () => InitError2,
+  Service: () => Service72,
+  locationLayer: () => locationLayer2,
+  node: () => node76
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { APICallError } from "@ai-sdk/provider";
+import {
+  LLMEvent,
+  AIError,
+  LanguageModel,
+  ProviderID,
+  ProviderMetadata,
+  TransportError,
+  ToolResultValue,
+  UnknownProviderError
+} from "@opencode/ai";
+import { Auth, Endpoint, RequestExecutor } from "@opencode/ai/route";
+import { ProviderShared } from "@opencode/ai/protocols/shared";
+import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream } from "effect";
+import { makeParser } from "effect/unstable/encoding/Sse";
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+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 decoder = new TextDecoder;
+  let deadline;
+  const parser = makeParser((event) => {
+    if (event._tag === "Event")
+      deadline = Date.now() + ms;
+  });
+  const body = new ReadableStream({
+    async pull(ctrl) {
+      const expires = deadline ?? Date.now() + ms;
+      deadline = expires;
+      const part = await new Promise((resolve, reject) => {
+        const remaining = Math.max(0, expires - Date.now());
+        const id = setTimeout(() => {
+          const err = new Error("SSE read timed out");
+          ctl.abort(err);
+          reader.cancel(err);
+          reject(err);
+        }, remaining);
+        reader.read().then((part) => {
+          clearTimeout(id);
+          resolve(part);
+        }, (err) => {
+          clearTimeout(id);
+          reject(err);
+        });
+      });
+      if (part.done) {
+        ctrl.close();
+        return;
+      }
+      parser.feed(decoder.decode(part.value, { stream: true }));
+      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.canonical ?? 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) => item !== undefined && item !== null);
+    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 (typeof opts.body === "string" && model.body !== undefined) {
+      const decoded = Option.getOrUndefined(decodeJson(opts.body));
+      if (Schema.is(Schema.Record(Schema.String, Schema.Json))(decoded)) {
+        opts.body = JSON.stringify(mergeOverlay2(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 InitError2 extends Schema.TaggedError()("AISDK.InitError", {
+  providerID: ID16,
+  cause: Schema.Defect()
+}) {
+}
+function initError(providerID) {
+  return Effect.catchCause((cause) => Effect.fail(new InitError2({ providerID, cause: Cause.squash(cause) })));
+}
+
+class Service72 extends Context.Service()("@opencode/AISDK") {
+}
+var locationLayer2 = Layer.effect(Service72, 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 = Service72.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,
+        canonical: model.canonical,
+        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 (!isAISDK2(model.package))
+        return yield* new InitError2({
+          providerID: model.providerID,
+          cause: new Error(`Unsupported package ${model.package}`)
+        });
+      const packageName = packageName2(model.package);
+      const options = prepareOptions(model, packageName);
+      const sdkKey = cacheKey({
+        providerID: model.providerID,
+        canonical: model.canonical,
+        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 InitError2({
+          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 = packageName2(info.package);
+  const projected = mapBodyToProviderOptions(info, packageName);
+  const providerID = info.canonical ?? info.providerID;
+  const optionKey = providerOptionKey(packageName, providerID);
+  const route = {
+    compact: undefined,
+    id: `ai-sdk:${packageName}`,
+    provider: ProviderID.make(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),
+      execute: () => Effect.succeed({ 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
+      },
+      providerOptions: projected.settings
+    },
+    body: {
+      schema: Schema.Unknown,
+      from: (request) => Effect.try({
+        try: () => callOptions(request, packageName, info.modelID ?? info.id, optionKey),
+        catch: (cause) => cause instanceof AIError ? cause : ProviderShared.invalidRequest("Invalid AI SDK request", cause)
+      })
+    },
+    with: () => route,
+    model: (input) => LanguageModel.make({ ...input, provider: "provider" in input ? input.provider : providerID, route }),
+    prepareTransport: (body) => Effect.succeed(body),
+    streamPrepared: (prepared) => streamLanguage(language, prepared)
+  };
+  return LanguageModel.make({
+    id: info.modelID ?? info.id,
+    provider: 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 (gateway !== undefined)
+    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 ? mergeOverlay2(settings, { forceReasoning: true }) : settings;
+  if (!pro)
+    return { settings: normalized, body: model.body };
+  const body = { ...model.body };
+  delete body.reasoning;
+  return {
+    settings: mergeOverlay2(normalized, { reasoningMode: "pro" }),
+    body: Object.keys(body).length === 0 ? undefined : body
+  };
+}
+function callOptions(request, packageName, modelID, optionKey) {
+  const flattened = ProviderShared.flattenToolRequest(request);
+  return {
+    prompt: prompt(flattened.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: flattened.tools.map(tool),
+    toolChoice: toolChoice(request.toolChoice),
+    headers: request.http?.headers,
+    providerOptions: requestProviderOptions(request.providerOptions, packageName, modelID, optionKey)
+  };
+}
+function prompt(request) {
+  const system = request.system.map((part) => part.text).filter(Boolean).join(`
+
+`);
+  const pending = [];
+  const messages = request.messages.flatMap((input, index) => {
+    if (input.role !== "tool")
+      return message(input);
+    const lowered = toolMessage(input);
+    pending.push(...lowered.media);
+    if (request.messages[index + 1]?.role === "tool" || pending.length === 0)
+      return lowered.messages;
+    const media = [...pending];
+    pending.length = 0;
+    return [
+      ...lowered.messages,
+      {
+        role: "user",
+        content: [{ type: "text", text: "Attached media from tool result:" }, ...media]
+      }
+    ];
+  });
+  if (!system.length)
+    return messages;
+  return [{ role: "system", content: system }, ...messages];
+}
+function message(input) {
+  switch (input.role) {
+    case "system":
+      return [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: ProviderShared.wrapSystemUpdate(input.content.filter((part) => part.type === "text"))
+            }
+          ]
+        }
+      ];
+    case "user":
+      return [{ role: "user", content: input.content.flatMap(userPart) }];
+    case "assistant":
+      return [{ role: "assistant", content: input.content.flatMap(assistantPart) }];
+    case "tool":
+      return toolMessage(input).messages;
+  }
+}
+function toolMessage(input) {
+  const media = [];
+  const content = input.content.flatMap((part) => {
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return toolResultPart(part);
+    const value = part.result.value.filter((item) => {
+      if (item.type !== "file")
+        return true;
+      if (!item.mime.startsWith("image/") && item.mime !== "application/pdf")
+        return true;
+      media.push({ type: "file", mediaType: item.mime, data: fileData(item.uri), filename: item.name });
+      return false;
+    });
+    return toolResultPart({
+      ...part,
+      result: value.length === 0 ? { type: "text", value: "Media attached in the following user message." } : { ...part.result, value }
+    });
+  });
+  return {
+    messages: content.length ? [{ role: "tool", content }] : [],
+    media
+  };
+}
+function userPart(part) {
+  if (part.type === "text")
+    return [{ type: "text", text: part.text }];
+  if (part.type === "media")
+    return [{ type: "file", mediaType: part.mediaType, data: fileData(part.data), filename: part.filename }];
+  return [];
+}
+function assistantPart(part) {
+  switch (part.type) {
+    case "compaction":
+      throw ProviderShared.unsupportedOperation({
+        operation: "compaction-replay",
+        provider: part.provider,
+        message: "AI SDK routes cannot replay native provider compaction state"
+      });
+    case "text":
+      return [{ type: "text", text: part.text, providerOptions: metadataProviderOptions(part.providerMetadata) }];
+    case "media":
+      return [{ type: "file", mediaType: part.mediaType, data: fileData(part.data), filename: part.filename }];
+    case "reasoning":
+      return [{ type: "reasoning", text: part.text, providerOptions: metadataProviderOptions(part.providerMetadata) }];
+    case "tool-call":
+      return [
+        {
+          type: "tool-call",
+          toolCallId: part.id,
+          toolName: part.name,
+          input: part.input,
+          providerExecuted: part.providerExecuted,
+          providerOptions: metadataProviderOptions(part.providerMetadata)
+        }
+      ];
+    case "tool-result":
+      return toolResultPart(part);
+  }
+}
+function fileData(data) {
+  if (typeof data !== "string")
+    return data;
+  const base64 = /^data:[^;,]+(?:;[^,]*)*;base64,(.*)$/s.exec(data)?.[1];
+  if (base64 !== undefined)
+    return base64;
+  if (!URL.canParse(data))
+    return data;
+  const url = new URL(data);
+  return url.protocol === "http:" || url.protocol === "https:" ? url : data;
+}
+function toolResultPart(part) {
+  if (part.type !== "tool-result")
+    return [];
+  return [
+    {
+      type: "tool-result",
+      toolCallId: part.id,
+      toolName: part.name,
+      output: toolOutput(part.result),
+      providerOptions: metadataProviderOptions(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 requestProviderOptions(input, packageName, modelID, optionKey) {
+  if (!input)
+    return;
+  const options = jsonObject(input);
+  if (packageName === "@ai-sdk/gateway")
+    return gatewayProviderOptions(modelID, options);
+  if (packageName === "@ai-sdk/azure")
+    return { openai: options, azure: options };
+  return { [optionKey]: options };
+}
+function metadataProviderOptions(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(error, "request")
+  }).pipe(Effect.map((result) => Stream.fromReadableStream({
+    evaluate: () => result.stream,
+    onError: (error) => llmError(error, "read")
+  }).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(event.error, "read"));
+  }
+}
+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(error, operation) {
+  if (error instanceof AIError)
+    return error;
+  if (APICallError.isInstance(error))
+    return apiCallError(error);
+  const network = networkFailure(error);
+  if (network)
+    return new AIError({
+      reason: new TransportError({
+        message: network.message.trim() === "" ? unknownErrorMessage(error) : network.message,
+        cause: error,
+        transport: "http",
+        operation,
+        code: network.code
+      })
+    });
+  return new AIError({
+    reason: new UnknownProviderError({
+      message: unknownErrorMessage(error),
+      body: errorBody(error),
+      cause: error
+    })
+  });
+}
+var NETWORK_ERROR_CODES = new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE",
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket"
+]);
+var NETWORK_ERROR_MESSAGES = new Set([
+  "fetch failed",
+  "failed to fetch",
+  "terminated",
+  "other side closed",
+  "sse read timed out"
+]);
+var NativeErrorShape = Schema.Struct({
+  message: Schema.String,
+  code: Schema.optionalKey(Schema.String),
+  cause: Schema.optionalKey(Schema.Unknown)
+});
+var decodeNativeErrorShape = Schema.decodeUnknownOption(NativeErrorShape);
+function networkFailure(error, depth = 0) {
+  if (depth > 4)
+    return;
+  const shape = Option.getOrUndefined(decodeNativeErrorShape(error));
+  if (!shape)
+    return;
+  const cause = networkFailure(shape.cause, depth + 1);
+  if (cause)
+    return cause;
+  if (shape.code !== undefined && (NETWORK_ERROR_CODES.has(shape.code) || shape.code.startsWith("UND_ERR")))
+    return { message: shape.message, code: shape.code };
+  if (NETWORK_ERROR_MESSAGES.has(shape.message.trim().toLowerCase()))
+    return { message: shape.message, code: shape.code };
+  return;
+}
+function apiCallError(error) {
+  const failure = RequestExecutor.httpFailure({
+    message: providerErrorMessage(error),
+    url: error.url,
+    status: error.statusCode,
+    data: error.data,
+    responseHeaders: error.responseHeaders,
+    responseBody: error.responseBody ?? errorBody(error.data),
+    cause: error
+  });
+  if (error.statusCode !== undefined || !error.isRetryable)
+    return failure;
+  return new AIError({
+    reason: new TransportError({
+      message: failure.message,
+      body: failure.reason.body,
+      http: failure.reason.http,
+      cause: failure.reason.cause,
+      transport: "http",
+      operation: "request",
+      url: error.url
+    })
+  });
+}
+function errorBody(value) {
+  if (typeof value === "string")
+    return value;
+  if (value instanceof Error || !Schema.is(Schema.Json)(value))
+    return;
+  return ProviderShared.encodeJson(value);
+}
+var ProviderErrorDetail = Schema.Struct({
+  message: Schema.optionalKey(Schema.String),
+  code: Schema.optionalKey(Schema.Union([Schema.String, Schema.Finite]))
+});
+var ProviderErrorBody = Schema.Struct({
+  ...ProviderErrorDetail.fields,
+  error: Schema.optionalKey(ProviderErrorDetail)
+});
+var decodeProviderError = Schema.decodeUnknownOption(Schema.Union([ProviderErrorBody, Schema.fromJsonString(ProviderErrorBody)]));
+function unknownErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.trim() === "" ? "Provider request failed" : message;
+}
+function providerErrorMessage(error) {
+  const data = Option.getOrUndefined(decodeProviderError(error.data));
+  const body = Option.getOrUndefined(decodeProviderError(error.responseBody));
+  const details = [data?.error, data, body?.error, body];
+  const message = details.map((detail) => detail?.message).find((value) => value?.trim());
+  const value = details.map((detail) => detail?.code).find((value) => value !== undefined);
+  const code = value === undefined ? undefined : String(value);
+  const prefix = error.statusCode === undefined ? "Provider request failed" : `Provider request failed with HTTP ${error.statusCode}`;
+  return error.message.trim() !== "" ? error.message : message ?? (code === undefined ? prefix : `${prefix}: ${code}`);
+}
+var node76 = makeLocationNode({ service: Service72, layer: locationLayer2, deps: [] });
+
+export { InitError2, Service72, locationLayer2, node76, exports_aisdk };