nah-studio 0.0.1-beta.2 → 0.0.1-beta.3

package/dist/index-3aTwEgol-DT2seYtV.js

@@ -0,0 +1,1320 @@
+import { a as Oe, _ as Se, K as D, r as L, Y as W, S as z, M as m, I as H, N as T, m as Ie, g as P, h as U, f as X, i as ee, F as de, ac as Ce, ad as Y, af as qe, w as Re, ag as Te, av as pe, P as u, an as ce, Z as C, U as he, u as A, a9 as N, R as q, O as _, ao as Ne, ah as Ue, a5 as ge, z as $e, T as V, A as B, a2 as Z, Q as Pe, V as je } from "./cli-pnTpS6rO.js";
+function $(e) {
+  return e.replace(/[_-]([a-z])/g, (t) => t[1].toUpperCase());
+}
+function Me(e, t) {
+  const o = $(e);
+  return o !== e && t?.[o] != null ? o : e;
+}
+function F({ rawName: e, providerOptions: t, warnings: o }) {
+  const s = $(e);
+  s !== e && t?.[e] != null && o.push({
+    type: "deprecated",
+    setting: `providerOptions key '${e}'`,
+    message: `Use '${s}' instead.`
+  });
+}
+const E = {
+  errorSchema: m({ error: m({
+    message: u(),
+    type: u().nullish(),
+    param: pe().nullish(),
+    code: z([u(), _()]).nullish()
+  }) }),
+  errorToMessage: (e) => e.error.message
+};
+function He(e) {
+  if (e == null) return ce();
+  const t = e.prompt_tokens ?? 0, o = e.completion_tokens ?? 0, s = e.prompt_tokens_details?.cached_tokens ?? 0, r = e.completion_tokens_details?.reasoning_tokens ?? 0;
+  return {
+    inputTokens: {
+      total: t,
+      noCache: t - s,
+      cacheRead: s,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: o,
+      text: Math.max(0, o - r),
+      reasoning: r
+    },
+    raw: e
+  };
+}
+function M(e) {
+  return e?.providerOptions?.openaiCompatible ?? {};
+}
+function Ae(e) {
+  switch (e) {
+    case "audio/wav":
+      return "wav";
+    case "audio/mp3":
+    case "audio/mpeg":
+      return "mp3";
+    default:
+      return null;
+  }
+}
+function me(e) {
+  const t = M(e);
+  switch (e.type) {
+    case "text":
+      return {
+        type: "text",
+        text: e.text,
+        ...t
+      };
+    case "file":
+      switch (e.data.type) {
+        case "reference":
+          throw new C({ functionality: "file parts with provider references" });
+        case "text":
+          throw new C({ functionality: "text file parts" });
+        case "url":
+        case "data": {
+          const o = $e(e.mediaType);
+          if (o === "image") return {
+            type: "image_url",
+            image_url: { url: e.data.type === "url" ? e.data.url.toString() : `data:${V({ part: e })};base64,${B(e.data.data)}` },
+            ...t
+          };
+          if (o === "video") return {
+            type: "video_url",
+            video_url: { url: e.data.type === "url" ? e.data.url.toString() : `data:${V({ part: e })};base64,${B(e.data.data)}` },
+            ...t
+          };
+          if (o === "audio") {
+            if (e.data.type === "url") throw new C({ functionality: "audio file parts with URLs" });
+            const s = V({ part: e }), r = Ae(s);
+            if (r === null) throw new C({ functionality: `audio media type ${s}` });
+            return {
+              type: "input_audio",
+              input_audio: {
+                data: B(e.data.data),
+                format: r
+              },
+              ...t
+            };
+          }
+          if (o === "application") {
+            if (e.data.type === "url") throw new C({ functionality: "PDF file parts with URLs" });
+            const s = V({ part: e });
+            if (s !== "application/pdf") throw new C({ functionality: `file part media type ${s}` });
+            return {
+              type: "file",
+              file: {
+                filename: e.filename ?? "document.pdf",
+                file_data: `data:application/pdf;base64,${B(e.data.data)}`
+              },
+              ...t
+            };
+          }
+          if (o === "text") return {
+            type: "text",
+            text: e.data.type === "url" ? e.data.url.toString() : typeof e.data.data == "string" ? new TextDecoder().decode(ge(e.data.data)) : new TextDecoder().decode(e.data.data),
+            ...t
+          };
+          throw new C({ functionality: `file part media type ${e.mediaType}` });
+        }
+      }
+  }
+}
+function Ee(e) {
+  if (e.type === "custom") throw new C({ functionality: "custom tool content parts" });
+  return me(e);
+}
+function Ke(e, { providerOptionsKey: t = "google", supportsMultiPartToolContent: o = !1 } = {}) {
+  const s = [];
+  for (const { role: r, content: i, ...f } of e) {
+    const d = M({ ...f });
+    switch (r) {
+      case "system":
+        s.push({
+          role: "system",
+          content: i,
+          ...d
+        });
+        break;
+      case "user":
+        if (i.length === 1 && i[0].type === "text") {
+          s.push({
+            role: "user",
+            content: i[0].text,
+            ...M(i[0])
+          });
+          break;
+        }
+        s.push({
+          role: "user",
+          content: i.map(me),
+          ...d
+        });
+        break;
+      case "assistant": {
+        let c = "", a = "";
+        const l = [];
+        for (const n of i) {
+          const p = M(n);
+          switch (n.type) {
+            case "text":
+              c += n.text;
+              break;
+            case "reasoning":
+              a += n.text;
+              break;
+            case "tool-call": {
+              const x = n.providerOptions?.[t]?.thoughtSignature ?? n.providerOptions?.google?.thoughtSignature;
+              l.push({
+                id: n.toolCallId,
+                type: "function",
+                function: {
+                  name: n.toolName,
+                  arguments: JSON.stringify(n.input)
+                },
+                ...p,
+                ...x ? { extra_content: { google: { thought_signature: String(x) } } } : {}
+              });
+              break;
+            }
+          }
+        }
+        s.push({
+          role: "assistant",
+          content: l.length > 0 ? c || null : c,
+          ...a.length > 0 ? { reasoning_content: a } : {},
+          tool_calls: l.length > 0 ? l : void 0,
+          ...d
+        });
+        break;
+      }
+      case "tool":
+        for (const c of i) {
+          if (c.type === "tool-approval-response") continue;
+          const a = c.output;
+          let l;
+          switch (a.type) {
+            case "text":
+            case "error-text":
+              l = a.value;
+              break;
+            case "execution-denied":
+              l = a.reason ?? "Tool call execution denied.";
+              break;
+            case "json":
+            case "error-json":
+              l = JSON.stringify(a.value);
+              break;
+            case "content":
+              l = o ? a.value.map(Ee) : JSON.stringify(a.value);
+          }
+          const n = M(c);
+          s.push({
+            role: "tool",
+            tool_call_id: c.toolCallId,
+            content: l,
+            ...n
+          });
+        }
+        break;
+      default:
+        throw new Error(`Unsupported role: ${r}`);
+    }
+  }
+  return s;
+}
+function te({ id: e, model: t, created: o }) {
+  return Y({
+    id: e,
+    model: t,
+    created: o || void 0
+  });
+}
+function oe(e) {
+  switch (e) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+const j = m({
+  /**
+  * A unique identifier representing your end-user, which can help the provider to
+  * monitor and detect abuse.
+  */
+  user: u().optional(),
+  /**
+  * Reasoning effort for reasoning models. Defaults to `medium`.
+  */
+  reasoningEffort: u().optional(),
+  /**
+  * Controls the verbosity of the generated text. Defaults to `medium`.
+  */
+  textVerbosity: u().optional(),
+  /**
+  * Whether to use strict JSON schema validation.
+  * When true, the model uses constrained decoding to guarantee schema compliance.
+  * Only used when the provider supports structured outputs and a schema is provided.
+  *
+  * @default true
+  */
+  strictJsonSchema: he().optional()
+});
+function Ve({ tools: e, toolChoice: t }) {
+  e = e?.length ? e : void 0;
+  const o = [];
+  if (e == null) return {
+    tools: void 0,
+    toolChoice: void 0,
+    toolWarnings: o
+  };
+  const s = [];
+  for (const i of e) i.type === "provider" ? o.push({
+    type: "unsupported",
+    feature: `provider-defined tool ${i.id}`
+  }) : s.push({
+    type: "function",
+    function: {
+      name: i.name,
+      description: i.description,
+      parameters: i.inputSchema,
+      ...i.strict != null ? { strict: i.strict } : {}
+    }
+  });
+  if (t == null) return {
+    tools: s,
+    toolChoice: void 0,
+    toolWarnings: o
+  };
+  const r = t.type;
+  switch (r) {
+    case "auto":
+    case "none":
+    case "required":
+      return {
+        tools: s,
+        toolChoice: r,
+        toolWarnings: o
+      };
+    case "tool":
+      return {
+        tools: s,
+        toolChoice: {
+          type: "function",
+          function: { name: t.toolName }
+        },
+        toolWarnings: o
+      };
+    default:
+      throw new C({ functionality: `tool choice type: ${r}` });
+  }
+}
+var Be = class fe {
+  static [D](t) {
+    return L({
+      modelId: t.modelId,
+      config: t.config
+    });
+  }
+  static [W](t) {
+    return new fe(t.modelId, t.config);
+  }
+  constructor(t, o) {
+    this.specificationVersion = "v4", this.modelId = t, this.config = o;
+    const s = o.errorStructure ?? E;
+    this.chunkSchema = We(s.errorSchema), this.failedResponseHandler = H(s), this.supportsStructuredOutputs = o.supportsStructuredOutputs ?? !1;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get supportedUrls() {
+    return this.config.supportedUrls?.() ?? {};
+  }
+  transformRequestBody(t) {
+    return this.config.transformRequestBody?.(t) ?? t;
+  }
+  convertUsage(t) {
+    return this.config.convertUsage?.(t) ?? He(t);
+  }
+  async getArgs({ prompt: t, maxOutputTokens: o, temperature: s, topP: r, topK: i, frequencyPenalty: f, presencePenalty: d, reasoning: c, providerOptions: a, stopSequences: l, responseFormat: n, seed: p, toolChoice: x, tools: y }) {
+    const v = [], k = await T({
+      provider: "openai-compatible",
+      providerOptions: a,
+      schema: j
+    });
+    k != null && v.push({
+      type: "deprecated",
+      setting: "providerOptions key 'openai-compatible'",
+      message: "Use 'openaiCompatible' instead."
+    }), F({
+      rawName: this.providerOptionsName,
+      providerOptions: a,
+      warnings: v
+    });
+    const b = Object.assign(k ?? {}, await T({
+      provider: "openaiCompatible",
+      providerOptions: a,
+      schema: j
+    }) ?? {}, await T({
+      provider: this.providerOptionsName,
+      providerOptions: a,
+      schema: j
+    }) ?? {}, await T({
+      provider: $(this.providerOptionsName),
+      providerOptions: a,
+      schema: j
+    }) ?? {}), O = b?.strictJsonSchema ?? !0;
+    i != null && v.push({
+      type: "unsupported",
+      feature: "topK"
+    }), n?.type === "json" && n.schema != null && !this.supportsStructuredOutputs && v.push({
+      type: "unsupported",
+      feature: "responseFormat",
+      details: "JSON response format schema is only supported with structuredOutputs"
+    });
+    const { tools: J, toolChoice: h, toolWarnings: g } = Ve({
+      tools: y,
+      toolChoice: x
+    }), w = Me(this.providerOptionsName, a);
+    return {
+      metadataKey: w,
+      args: {
+        model: this.modelId,
+        user: b.user,
+        max_tokens: o,
+        temperature: s,
+        top_p: r,
+        frequency_penalty: f,
+        presence_penalty: d,
+        response_format: n?.type === "json" ? this.supportsStructuredOutputs === !0 && n.schema != null ? {
+          type: "json_schema",
+          json_schema: {
+            schema: n.schema,
+            strict: O,
+            name: n.name ?? "response",
+            description: n.description
+          }
+        } : { type: "json_object" } : void 0,
+        stop: l,
+        seed: p,
+        ...Object.fromEntries(Object.entries({
+          ...a?.[this.providerOptionsName],
+          ...a?.[$(this.providerOptionsName)]
+        }).filter(([S]) => !Object.keys(j.shape).includes(S))),
+        reasoning_effort: b.reasoningEffort ?? (Ie(c) ? c : void 0),
+        verbosity: b.textVerbosity,
+        messages: Ke(t, {
+          providerOptionsKey: w,
+          supportsMultiPartToolContent: this.config.supportsMultiPartToolContent
+        }),
+        tools: J,
+        tool_choice: h
+      },
+      warnings: [...v, ...g]
+    };
+  }
+  async doGenerate(t) {
+    const { args: o, warnings: s, metadataKey: r } = await this.getArgs({ ...t }), i = this.transformRequestBody(o), f = JSON.stringify(i), { responseHeaders: d, value: c, rawValue: a } = await P({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: U(this.config.headers?.(), t.headers),
+      body: i,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: A(De),
+      abortSignal: t.abortSignal,
+      fetch: this.config.fetch
+    }), l = c.choices[0];
+    if (l == null) throw new X({
+      data: a,
+      message: "Response did not contain any choices."
+    });
+    const n = [];
+    n.push(...ne(l.message.content));
+    const p = l.message.reasoning_content ?? l.message.reasoning;
+    if (p != null && p.length > 0 && n.push({
+      type: "reasoning",
+      text: p
+    }), l.message.tool_calls != null) for (const v of l.message.tool_calls) {
+      const k = v.extra_content?.google?.thought_signature;
+      n.push({
+        type: "tool-call",
+        toolCallId: v.id || ee(),
+        toolName: v.function.name,
+        input: v.function.arguments,
+        ...k ? { providerMetadata: { [r]: { thoughtSignature: k } } } : {}
+      });
+    }
+    const x = {
+      [r]: {},
+      ...await this.config.metadataExtractor?.extractMetadata?.({ parsedBody: a })
+    }, y = c.usage?.completion_tokens_details;
+    return y?.accepted_prediction_tokens != null && (x[r].acceptedPredictionTokens = y?.accepted_prediction_tokens), y?.rejected_prediction_tokens != null && (x[r].rejectedPredictionTokens = y?.rejected_prediction_tokens), {
+      content: n,
+      finishReason: {
+        unified: oe(l.finish_reason),
+        raw: l.finish_reason ?? void 0
+      },
+      usage: this.convertUsage(c.usage),
+      providerMetadata: x,
+      request: { body: f },
+      response: {
+        ...te(c),
+        headers: d,
+        body: a
+      },
+      warnings: s
+    };
+  }
+  async doStream(t) {
+    const { args: o, warnings: s, metadataKey: r } = await this.getArgs({ ...t }), i = this.transformRequestBody({
+      ...o,
+      stream: !0,
+      stream_options: this.config.includeUsage ? { include_usage: !0 } : void 0
+    }), f = this.config.metadataExtractor?.createStreamExtractor(), { responseHeaders: d, value: c } = await P({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: U(this.config.headers?.(), t.headers),
+      body: i,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: de(this.chunkSchema),
+      abortSignal: t.abortSignal,
+      fetch: this.config.fetch
+    }), a = r;
+    let l;
+    const n = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Set(), x = (h) => {
+      const g = h.index;
+      if (g == null || p.has(g)) {
+        l.processDelta(h);
+        return;
+      }
+      let w = n.get(g);
+      w == null ? (w = {
+        id: h.id ?? null,
+        bufferedArguments: "",
+        extraContent: h.extra_content ?? null
+      }, n.set(g, w)) : (w.id == null && h.id != null && (w.id = h.id), w.extraContent == null && h.extra_content != null && (w.extraContent = h.extra_content));
+      const S = h.function?.arguments;
+      S != null && (w.bufferedArguments += S);
+      const R = h.function?.name;
+      if (R != null) {
+        const K = {
+          index: g,
+          id: w.id,
+          function: {
+            name: R,
+            arguments: w.bufferedArguments
+          },
+          extra_content: w.extraContent ?? void 0
+        };
+        l.processDelta(K), n.delete(g), p.add(g);
+      }
+    };
+    let y, v, k = !1, b = !1, O = !1;
+    const J = (h) => this.convertUsage(h);
+    return {
+      stream: c.pipeThrough(new TransformStream({
+        start(h) {
+          l = new Ce(h, {
+            generateId: ee,
+            extractMetadata: (g) => {
+              const w = g.extra_content?.google?.thought_signature;
+              return w ? { [a]: { thoughtSignature: w } } : void 0;
+            },
+            buildToolCallProviderMetadata: (g) => g
+          }), h.enqueue({
+            type: "stream-start",
+            warnings: s
+          });
+        },
+        transform(h, g) {
+          if (t.includeRawChunks && g.enqueue({
+            type: "raw",
+            rawValue: h.rawValue
+          }), !h.success) {
+            y = {
+              unified: "error",
+              raw: void 0
+            }, g.enqueue({
+              type: "error",
+              error: h.error
+            });
+            return;
+          }
+          if (f?.processChunk(h.rawValue), "error" in h.value) {
+            y = {
+              unified: "error",
+              raw: void 0
+            }, g.enqueue({
+              type: "error",
+              error: h.value.error
+            });
+            return;
+          }
+          const w = h.value;
+          if (!k) {
+            const I = te(w);
+            Object.values(I).some(Boolean) && (k = !0, g.enqueue({
+              type: "response-metadata",
+              ...I
+            }));
+          }
+          w.usage != null && (v = w.usage);
+          const S = w.choices[0];
+          if (S?.finish_reason != null && (y = {
+            unified: oe(S.finish_reason),
+            raw: S.finish_reason ?? void 0
+          }), S?.delta == null) return;
+          const R = S.delta, K = (I) => {
+            O && (g.enqueue({
+              type: "text-end",
+              id: "txt-0"
+            }), O = !1), b || (g.enqueue({
+              type: "reasoning-start",
+              id: "reasoning-0"
+            }), b = !0), g.enqueue({
+              type: "reasoning-delta",
+              id: "reasoning-0",
+              delta: I
+            });
+          }, ke = (I) => {
+            b && (g.enqueue({
+              type: "reasoning-end",
+              id: "reasoning-0"
+            }), b = !1), O || (g.enqueue({
+              type: "text-start",
+              id: "txt-0"
+            }), O = !0), g.enqueue({
+              type: "text-delta",
+              id: "txt-0",
+              delta: I
+            });
+          }, Q = R.reasoning_content ?? R.reasoning;
+          Q && K(Q);
+          for (const I of ne(R.content)) I.type === "reasoning" ? K(I.text) : ke(I.text);
+          if (R.tool_calls != null && R.tool_calls.length > 0) {
+            b && (g.enqueue({
+              type: "reasoning-end",
+              id: "reasoning-0"
+            }), b = !1);
+            for (const I of R.tool_calls) x(I);
+          }
+        },
+        flush(h) {
+          b && h.enqueue({
+            type: "reasoning-end",
+            id: "reasoning-0"
+          }), O && h.enqueue({
+            type: "text-end",
+            id: "txt-0"
+          });
+          for (const [w, S] of n) l.processDelta({
+            index: w,
+            id: S.id,
+            function: { arguments: S.bufferedArguments }
+          });
+          n.clear(), l.flush(), y == null && (y = {
+            unified: "error",
+            raw: void 0
+          }, h.enqueue({
+            type: "error",
+            error: new X({
+              data: void 0,
+              message: "Response stream ended without a finish reason."
+            })
+          }));
+          const g = {
+            [a]: {},
+            ...f?.buildMetadata()
+          };
+          v?.completion_tokens_details?.accepted_prediction_tokens != null && (g[a].acceptedPredictionTokens = v?.completion_tokens_details?.accepted_prediction_tokens), v?.completion_tokens_details?.rejected_prediction_tokens != null && (g[a].rejectedPredictionTokens = v?.completion_tokens_details?.rejected_prediction_tokens), h.enqueue({
+            type: "finish",
+            finishReason: y,
+            usage: J(v),
+            providerMetadata: g
+          });
+        }
+      })),
+      request: { body: i },
+      response: { headers: d }
+    };
+  }
+};
+const ye = N({
+  prompt_tokens: _().nullish(),
+  completion_tokens: _().nullish(),
+  total_tokens: _().nullish(),
+  prompt_tokens_details: N({ cached_tokens: _().nullish() }).nullish(),
+  completion_tokens_details: N({
+    reasoning_tokens: _().nullish(),
+    accepted_prediction_tokens: _().nullish(),
+    rejected_prediction_tokens: _().nullish()
+  }).nullish()
+}).nullish(), ve = z([u(), q(N({ type: u() }))]).nullish();
+function ne(e) {
+  if (e == null) return [];
+  if (typeof e == "string") return e.length > 0 ? [{
+    type: "text",
+    text: e
+  }] : [];
+  const t = [];
+  for (const o of e) if (o.type === "text" && typeof o.text == "string")
+    o.text.length > 0 && t.push({
+      type: "text",
+      text: o.text
+    });
+  else if (o.type === "thinking" && Array.isArray(o.thinking)) {
+    const s = o.thinking.filter((r) => r != null && typeof r == "object" && "type" in r && r.type === "text" && "text" in r && typeof r.text == "string").map((r) => r.text).join("");
+    s.length > 0 && t.push({
+      type: "reasoning",
+      text: s
+    });
+  }
+  return t;
+}
+const De = N({
+  id: u().nullish(),
+  created: _().nullish(),
+  model: u().nullish(),
+  choices: q(m({
+    message: m({
+      role: Pe("assistant").nullish(),
+      content: ve,
+      reasoning_content: u().nullish(),
+      reasoning: u().nullish(),
+      tool_calls: q(m({
+        id: u().nullish(),
+        function: m({
+          name: u(),
+          arguments: u()
+        }),
+        extra_content: m({ google: m({ thought_signature: u().nullish() }).nullish() }).nullish()
+      })).nullish()
+    }),
+    finish_reason: u().nullish()
+  })),
+  usage: ye
+}), Le = N({
+  id: u().nullish(),
+  created: _().nullish(),
+  model: u().nullish(),
+  choices: q(m({
+    delta: m({
+      role: je(["assistant", ""]).nullish(),
+      content: ve,
+      reasoning_content: u().nullish(),
+      reasoning: u().nullish(),
+      tool_calls: q(m({
+        index: _().nullish(),
+        id: u().nullish(),
+        function: m({
+          name: u().nullish(),
+          arguments: u().nullish()
+        }),
+        extra_content: m({ google: m({ thought_signature: u().nullish() }).nullish() }).nullish()
+      })).nullish()
+    }).nullish(),
+    finish_reason: u().nullish()
+  })),
+  usage: ye
+}), We = (e) => z([Le, e]);
+function se(e) {
+  if (e == null) return ce();
+  const t = e.prompt_tokens ?? 0, o = e.completion_tokens ?? 0;
+  return {
+    inputTokens: {
+      total: t,
+      noCache: t,
+      cacheRead: void 0,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: o,
+      text: o,
+      reasoning: void 0
+    },
+    raw: e
+  };
+}
+function ze({ prompt: e, user: t = "user", assistant: o = "assistant" }) {
+  let s = "";
+  e[0].role === "system" && (s += `${e[0].content}
+
+`, e = e.slice(1));
+  for (const { role: r, content: i } of e) switch (r) {
+    case "system":
+      throw new Ne({
+        message: "Unexpected system message in prompt: ${content}",
+        prompt: e
+      });
+    case "user": {
+      const f = i.map((d) => {
+        switch (d.type) {
+          case "text":
+            return d.text;
+        }
+      }).filter(Boolean).join("");
+      s += `${t}:
+${f}
+
+`;
+      break;
+    }
+    case "assistant": {
+      const f = i.map((d) => {
+        switch (d.type) {
+          case "text":
+            return d.text;
+          case "tool-call":
+            throw new C({ functionality: "tool-call messages" });
+        }
+      }).join("");
+      s += `${o}:
+${f}
+
+`;
+      break;
+    }
+    case "tool":
+      throw new C({ functionality: "tool messages" });
+    default:
+      throw new Error(`Unsupported role: ${r}`);
+  }
+  return s += `${o}:
+`, {
+    prompt: s,
+    stopSequences: [`
+${t}:`]
+  };
+}
+function re(e) {
+  switch (e) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+const ae = m({
+  /**
+  * Echo back the prompt in addition to the completion.
+  */
+  echo: he().optional(),
+  /**
+  * Modify the likelihood of specified tokens appearing in the completion.
+  *
+  * Accepts a JSON object that maps tokens (specified by their token ID in
+  * the GPT tokenizer) to an associated bias value from -100 to 100.
+  */
+  logitBias: Z(u(), _()).optional(),
+  /**
+  * The suffix that comes after a completion of inserted text.
+  */
+  suffix: u().optional(),
+  /**
+  * A unique identifier representing your end-user, which can help providers to
+  * monitor and detect abuse.
+  */
+  user: u().optional()
+});
+var Fe = class we {
+  static [D](t) {
+    return L({
+      modelId: t.modelId,
+      config: t.config
+    });
+  }
+  static [W](t) {
+    return new we(t.modelId, t.config);
+  }
+  constructor(t, o) {
+    this.specificationVersion = "v4", this.modelId = t, this.config = o;
+    const s = o.errorStructure ?? E;
+    this.chunkSchema = Ge(s.errorSchema), this.failedResponseHandler = H(s);
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get supportedUrls() {
+    return this.config.supportedUrls?.() ?? {};
+  }
+  async getArgs({ prompt: t, maxOutputTokens: o, temperature: s, topP: r, topK: i, frequencyPenalty: f, presencePenalty: d, stopSequences: c, responseFormat: a, seed: l, providerOptions: n, tools: p, toolChoice: x }) {
+    const y = [];
+    F({
+      rawName: this.providerOptionsName,
+      providerOptions: n,
+      warnings: y
+    });
+    const v = Object.assign(await T({
+      provider: this.providerOptionsName,
+      providerOptions: n,
+      schema: ae
+    }) ?? {}, await T({
+      provider: $(this.providerOptionsName),
+      providerOptions: n,
+      schema: ae
+    }) ?? {});
+    i != null && y.push({
+      type: "unsupported",
+      feature: "topK"
+    }), p?.length && y.push({
+      type: "unsupported",
+      feature: "tools"
+    }), x != null && y.push({
+      type: "unsupported",
+      feature: "toolChoice"
+    }), a != null && a.type !== "text" && y.push({
+      type: "unsupported",
+      feature: "responseFormat",
+      details: "JSON response format is not supported."
+    });
+    const { prompt: k, stopSequences: b } = ze({ prompt: t }), O = [...b ?? [], ...c ?? []];
+    return {
+      args: {
+        model: this.modelId,
+        echo: v.echo,
+        logit_bias: v.logitBias,
+        suffix: v.suffix,
+        user: v.user,
+        max_tokens: o,
+        temperature: s,
+        top_p: r,
+        frequency_penalty: f,
+        presence_penalty: d,
+        seed: l,
+        ...n?.[this.providerOptionsName],
+        ...n?.[$(this.providerOptionsName)],
+        prompt: k,
+        stop: O.length > 0 ? O : void 0
+      },
+      warnings: y
+    };
+  }
+  async doGenerate(t) {
+    const { args: o, warnings: s } = await this.getArgs(t), { responseHeaders: r, value: i, rawValue: f } = await P({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: U(this.config.headers?.(), t.headers),
+      body: o,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: A(Je),
+      abortSignal: t.abortSignal,
+      fetch: this.config.fetch
+    }), d = i.choices[0], c = [];
+    return d.text != null && d.text.length > 0 && c.push({
+      type: "text",
+      text: d.text
+    }), {
+      content: c,
+      usage: se(i.usage),
+      finishReason: {
+        unified: re(d.finish_reason),
+        raw: d.finish_reason
+      },
+      request: { body: o },
+      response: {
+        ...Y(i),
+        headers: r,
+        body: f
+      },
+      warnings: s
+    };
+  }
+  async doStream(t) {
+    const { args: o, warnings: s } = await this.getArgs(t), r = {
+      ...o,
+      stream: !0,
+      stream_options: this.config.includeUsage ? { include_usage: !0 } : void 0
+    }, { responseHeaders: i, value: f } = await P({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: U(this.config.headers?.(), t.headers),
+      body: r,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: de(this.chunkSchema),
+      abortSignal: t.abortSignal,
+      fetch: this.config.fetch
+    });
+    let d = {
+      unified: "other",
+      raw: void 0
+    }, c, a = !0;
+    return {
+      stream: f.pipeThrough(new TransformStream({
+        start(l) {
+          l.enqueue({
+            type: "stream-start",
+            warnings: s
+          });
+        },
+        transform(l, n) {
+          if (t.includeRawChunks && n.enqueue({
+            type: "raw",
+            rawValue: l.rawValue
+          }), !l.success) {
+            d = {
+              unified: "error",
+              raw: void 0
+            }, n.enqueue({
+              type: "error",
+              error: l.error
+            });
+            return;
+          }
+          const p = l.value;
+          if ("error" in p) {
+            d = {
+              unified: "error",
+              raw: void 0
+            }, n.enqueue({
+              type: "error",
+              error: p.error
+            });
+            return;
+          }
+          a && (a = !1, n.enqueue({
+            type: "response-metadata",
+            ...Y(p)
+          }), n.enqueue({
+            type: "text-start",
+            id: "0"
+          })), p.usage != null && (c = p.usage);
+          const x = p.choices[0];
+          x?.finish_reason != null && (d = {
+            unified: re(x.finish_reason),
+            raw: x.finish_reason ?? void 0
+          }), x?.text != null && n.enqueue({
+            type: "text-delta",
+            id: "0",
+            delta: x.text
+          });
+        },
+        flush(l) {
+          a || l.enqueue({
+            type: "text-end",
+            id: "0"
+          }), l.enqueue({
+            type: "finish",
+            finishReason: d,
+            usage: se(c)
+          });
+        }
+      })),
+      request: { body: r },
+      response: { headers: i }
+    };
+  }
+};
+const _e = N({
+  prompt_tokens: _(),
+  completion_tokens: _(),
+  total_tokens: _()
+}), Je = m({
+  id: u().nullish(),
+  created: _().nullish(),
+  model: u().nullish(),
+  choices: q(m({
+    text: u(),
+    finish_reason: u()
+  })),
+  usage: _e.nullish()
+}), Ge = (e) => z([m({
+  id: u().nullish(),
+  created: _().nullish(),
+  model: u().nullish(),
+  choices: q(m({
+    text: u(),
+    finish_reason: u().nullish(),
+    index: _()
+  })),
+  usage: _e.nullish()
+}), e]), G = m({
+  /**
+  * The number of dimensions the resulting output embeddings should have.
+  * Only supported in text-embedding-3 and later models.
+  */
+  dimensions: _().optional(),
+  /**
+  * A unique identifier representing your end-user, which can help providers to
+  * monitor and detect abuse.
+  */
+  user: u().optional()
+});
+var Ye = class xe {
+  get provider() {
+    return this.config.provider;
+  }
+  get maxEmbeddingsPerCall() {
+    return this.config.maxEmbeddingsPerCall ?? 2048;
+  }
+  get supportsParallelCalls() {
+    return this.config.supportsParallelCalls ?? !0;
+  }
+  static [D](t) {
+    return L({
+      modelId: t.modelId,
+      config: t.config
+    });
+  }
+  static [W](t) {
+    return new xe(t.modelId, t.config);
+  }
+  constructor(t, o) {
+    this.specificationVersion = "v4", this.modelId = t, this.config = o;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  async doEmbed({ values: t, headers: o, abortSignal: s, providerOptions: r }) {
+    const i = [], f = await T({
+      provider: "openai-compatible",
+      providerOptions: r,
+      schema: G
+    });
+    f != null && i.push({
+      type: "deprecated",
+      setting: "providerOptions key 'openai-compatible'",
+      message: "Use 'openaiCompatible' instead."
+    }), F({
+      rawName: this.providerOptionsName,
+      providerOptions: r,
+      warnings: i
+    });
+    const d = Object.assign(f ?? {}, await T({
+      provider: "openaiCompatible",
+      providerOptions: r,
+      schema: G
+    }) ?? {}, await T({
+      provider: this.providerOptionsName,
+      providerOptions: r,
+      schema: G
+    }) ?? {});
+    if (t.length > this.maxEmbeddingsPerCall) throw new qe({
+      provider: this.provider,
+      modelId: this.modelId,
+      maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+      values: t
+    });
+    const { responseHeaders: c, value: a, rawValue: l } = await P({
+      url: this.config.url({
+        path: "/embeddings",
+        modelId: this.modelId
+      }),
+      headers: U(this.config.headers?.(), o),
+      body: {
+        model: this.modelId,
+        input: t,
+        encoding_format: "float",
+        dimensions: d.dimensions,
+        user: d.user
+      },
+      failedResponseHandler: H(this.config.errorStructure ?? E),
+      successfulResponseHandler: A(Ze),
+      abortSignal: s,
+      fetch: this.config.fetch
+    });
+    return {
+      warnings: i,
+      embeddings: a.data.map((n) => n.embedding),
+      usage: a.usage ? { tokens: a.usage.prompt_tokens } : void 0,
+      providerMetadata: a.providerMetadata,
+      response: {
+        headers: c,
+        body: l
+      }
+    };
+  }
+};
+const Ze = m({
+  data: q(m({ embedding: q(_()) })),
+  usage: m({ prompt_tokens: _() }).nullish(),
+  providerMetadata: Z(u(), Z(u(), pe())).optional()
+});
+var Qe = class be {
+  get provider() {
+    return this.config.provider;
+  }
+  /**
+  * The provider options key used to extract provider-specific options.
+  */
+  get providerOptionsKey() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  static [D](t) {
+    return L({
+      modelId: t.modelId,
+      config: t.config
+    });
+  }
+  static [W](t) {
+    return new be(t.modelId, t.config);
+  }
+  constructor(t, o) {
+    this.modelId = t, this.config = o, this.specificationVersion = "v4", this.maxImagesPerCall = 10, this.supportsFileInputs = void 0, this.supportsMaskInputs = void 0;
+  }
+  getArgs(t, o) {
+    return F({
+      rawName: this.providerOptionsKey,
+      providerOptions: t,
+      warnings: o
+    }), {
+      ...t[this.providerOptionsKey],
+      ...t[$(this.providerOptionsKey)]
+    };
+  }
+  async doGenerate({ prompt: t, n: o, size: s, aspectRatio: r, seed: i, providerOptions: f, headers: d, abortSignal: c, files: a, mask: l }) {
+    const n = [];
+    r != null && n.push({
+      type: "unsupported",
+      feature: "aspectRatio",
+      details: "This model does not support aspect ratio. Use `size` instead."
+    }), i != null && n.push({
+      type: "unsupported",
+      feature: "seed"
+    });
+    const p = this.config._internal?.currentDate?.() ?? /* @__PURE__ */ new Date(), x = this.getArgs(f, n);
+    if (a != null && a.length > 0) {
+      const { value: k, responseHeaders: b } = await Re({
+        url: this.config.url({
+          path: "/images/edits",
+          modelId: this.modelId
+        }),
+        headers: U(this.config.headers?.(), d),
+        formData: Te({
+          model: this.modelId,
+          prompt: t,
+          image: await Promise.all(a.map((O) => ue(O))),
+          mask: l != null ? await ue(l) : void 0,
+          n: o,
+          size: s,
+          ...x
+        }),
+        failedResponseHandler: H(this.config.errorStructure ?? E),
+        successfulResponseHandler: A(le),
+        abortSignal: c,
+        fetch: this.config.fetch
+      });
+      return {
+        images: k.data.map((O) => O.b64_json),
+        warnings: n,
+        usage: ie(k.usage),
+        response: {
+          timestamp: p,
+          modelId: this.modelId,
+          headers: b
+        }
+      };
+    }
+    const { value: y, responseHeaders: v } = await P({
+      url: this.config.url({
+        path: "/images/generations",
+        modelId: this.modelId
+      }),
+      headers: U(this.config.headers?.(), d),
+      body: {
+        model: this.modelId,
+        prompt: t,
+        n: o,
+        size: s,
+        ...x
+      },
+      failedResponseHandler: H(this.config.errorStructure ?? E),
+      successfulResponseHandler: A(le),
+      abortSignal: c,
+      fetch: this.config.fetch
+    });
+    return {
+      images: y.data.map((k) => k.b64_json),
+      warnings: n,
+      usage: ie(y.usage),
+      response: {
+        timestamp: p,
+        modelId: this.modelId,
+        headers: v
+      }
+    };
+  }
+};
+function ie(e) {
+  return e == null ? void 0 : {
+    inputTokens: e.input_tokens ?? void 0,
+    outputTokens: e.output_tokens ?? void 0,
+    totalTokens: e.total_tokens ?? void 0
+  };
+}
+const le = m({
+  data: q(m({ b64_json: u() })),
+  usage: m({
+    input_tokens: _().nullish(),
+    output_tokens: _().nullish(),
+    total_tokens: _().nullish()
+  }).nullish()
+});
+async function ue(e) {
+  if (e.type === "url") return Ue(e.url);
+  const t = e.data instanceof Uint8Array ? e.data : ge(e.data);
+  return new Blob([t], { type: e.mediaType });
+}
+const Xe = "3.0.62";
+function tt(e) {
+  const t = Oe(e.baseURL), o = e.name, s = {
+    ...e.apiKey && { Authorization: `Bearer ${e.apiKey}` },
+    ...e.headers
+  }, r = () => Se(s, `ai-sdk-openai-compatible/${Xe}`), i = (p) => ({
+    provider: `${o}.${p}`,
+    url: ({ path: x }) => {
+      const y = new URL(`${t}${x}`);
+      return e.queryParams && (y.search = new URLSearchParams(e.queryParams).toString()), y.toString();
+    },
+    headers: r,
+    fetch: e.fetch
+  }), f = (p) => d(p), d = (p) => new Be(p, {
+    ...i("chat"),
+    includeUsage: e.includeUsage,
+    supportsStructuredOutputs: e.supportsStructuredOutputs,
+    supportsMultiPartToolContent: e.supportsMultiPartToolContent,
+    supportedUrls: e.supportedUrls,
+    transformRequestBody: e.transformRequestBody,
+    metadataExtractor: e.metadataExtractor,
+    convertUsage: e.convertUsage
+  }), c = (p) => new Fe(p, {
+    ...i("completion"),
+    includeUsage: e.includeUsage
+  }), a = (p) => new Ye(p, { ...i("embedding") }), l = (p) => new Qe(p, i("image")), n = (p) => f(p);
+  return n.specificationVersion = "v4", n.languageModel = f, n.chatModel = d, n.completionModel = c, n.embeddingModel = a, n.textEmbeddingModel = a, n.imageModel = l, n;
+}
+export {
+  Be as OpenAICompatibleChatLanguageModel,
+  Fe as OpenAICompatibleCompletionLanguageModel,
+  Ye as OpenAICompatibleEmbeddingModel,
+  Qe as OpenAICompatibleImageModel,
+  Xe as VERSION,
+  tt as createOpenAICompatible
+};