@sortedyuan/maybecode 0.3.2 → 0.5.0

package/dist/cli/chunk-WVIRS76R.js

@@ -0,0 +1,4057 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  createParser
+} from "./chunk-UQDZ55LQ.js";
+import {
+  __name
+} from "./chunk-E732GDOI.js";
+
+// packages/providers/dist/capabilities.js
+import { createHash } from "node:crypto";
+import { MODEL_CAPABILITY_KEYS, parseMayConfig } from "@sortedyuan/may/config";
+import { omitUndefined } from "@sortedyuan/may/core";
+var ModelCapabilityResolver = class {
+  static {
+    __name(this, "ModelCapabilityResolver");
+  }
+  discoveries;
+  ttl;
+  maxEntries;
+  maxRecords;
+  adapters;
+  cache = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  records = [];
+  constructor(options = {}) {
+    this.discoveries = options.discoveries ?? [new ModelListCapabilityDiscovery(options.fetch ?? globalThis.fetch)];
+    this.ttl = positive(options.cacheTtlMs ?? 3e5, "cacheTtlMs");
+    this.maxEntries = positive(options.maxCacheEntries ?? 128, "maxCacheEntries");
+    this.maxRecords = positive(options.maxVerificationRecords ?? 256, "maxVerificationRecords");
+    this.adapters = structuredClone(options.adapterCapabilities ?? {});
+    for (const fields of Object.values(this.adapters))
+      assertCapabilityFields(fields);
+  }
+  async resolve(selection, options = {}) {
+    const requested = options.fields ?? MODEL_CAPABILITY_KEYS;
+    for (const field of requested)
+      if (!MODEL_CAPABILITY_KEYS.includes(field))
+        throw new TypeError(`Unknown capability field ${field}`);
+    const explicit = declaredFields(selection.capabilities, "user");
+    assertCapabilityFields(explicit);
+    const explicitReasoning = declaredReasoning(selection.capabilities, "user");
+    if (explicitReasoning !== void 0)
+      assertReasoningCapabilities(explicitReasoning);
+    const discovered = await this.discover(selection, options.refresh === true, explicitReasoning !== void 0, requested);
+    const model = {};
+    const adapter = this.adapters[selection.adapter] ?? builtinAdapterCapabilities(selection.adapter);
+    const connection = declaredFields(selection.providerConfig.capabilities, "user");
+    assertCapabilityFields(connection);
+    const connectionReasoning = declaredReasoning(selection.providerConfig.capabilities, "user");
+    if (connectionReasoning !== void 0)
+      assertReasoningCapabilities(connectionReasoning);
+    const effective = {};
+    for (const field of requested) {
+      const value = explicit[field] ?? declaredLimit(selection, field) ?? discovered.fields[field] ?? UNKNOWN;
+      model[field] = value;
+      effective[field] = intersectCapability(field, [value, adapter[field], connection[field]]);
+    }
+    const reasoning = explicitReasoning ?? discovered.reasoningEffort ?? builtinReasoningEffort(selection) ?? UNKNOWN;
+    const reasoningEffort = intersectReasoning(reasoning, connectionReasoning);
+    const layers = { model, adapter, connection };
+    return structuredClone({
+      reasoningEffort,
+      fields: effective,
+      layers,
+      version: digest({ reasoningEffort, fields: effective, layers }),
+      observedAt: discovered.observedAt,
+      expiresAt: discovered.expiresAt,
+      diagnostics: discovered.diagnostics
+    });
+  }
+  invalidate(selection) {
+    if (selection === void 0) {
+      this.cache.clear();
+      this.pending.clear();
+      return;
+    }
+    const prefix = connectionIdentity(selection);
+    for (const key of [...this.cache.keys(), ...this.pending.keys()]) {
+      if (!key.startsWith(prefix))
+        continue;
+      this.cache.delete(key);
+      this.pending.delete(key);
+    }
+  }
+  verificationRecords(selection) {
+    const connectionId = selection === void 0 ? void 0 : connectionIdentity(selection);
+    return this.records.filter((record) => connectionId === void 0 || record.connectionId === connectionId && record.model === selection?.model).map((record) => ({ ...record, parameters: { ...record.parameters } }));
+  }
+  recordVerification(selection, request, success, responseValidated = false, additionalCapabilities = []) {
+    const used = new Set(additionalCapabilities);
+    for (const message of request.messages)
+      for (const part of message.content) {
+        if (part.type === "text" || part.type === "json")
+          used.add("input.text");
+        if (["image", "audio", "file", "resource"].includes(part.type))
+          used.add(`input.${part.type}`);
+      }
+    if (request.tools.length > 0)
+      used.add("tools");
+    if (request.responseFormat !== void 0)
+      used.add(request.responseFormat.type === "json" ? "structuredOutput.json" : "structuredOutput.jsonSchema");
+    const thinking = selection.options.thinking;
+    const activeThinking = thinking !== void 0 && thinking !== "disabled" && !(isRecord(thinking) && thinking.type === "disabled");
+    if (selection.options.reasoningEffort !== void 0 || activeThinking || selection.options.reasoningSummary !== void 0)
+      used.add("reasoning.modes");
+    const parameters = {};
+    if (typeof selection.options.reasoningEffort === "string")
+      parameters.reasoningEffort = selection.options.reasoningEffort;
+    for (const key of ["maxTokens", "maxOutputTokens"])
+      if (typeof selection.options[key] === "number")
+        parameters[key] = selection.options[key];
+    if (parameters.maxTokens === void 0 && parameters.maxOutputTokens === void 0 && selection.limits?.maxOutputTokens !== void 0) {
+      parameters[["deepseek-chat", "kimi-chat", "zhipu-chat", "anthropic-messages"].includes(selection.adapter) ? "maxTokens" : "maxOutputTokens"] = selection.limits.maxOutputTokens;
+    }
+    if (typeof selection.options.reasoningSummary === "string")
+      parameters.reasoningSummary = selection.options.reasoningSummary;
+    if (typeof thinking === "string")
+      parameters.thinkingType = thinking;
+    else if (isRecord(thinking)) {
+      if (typeof thinking.type === "string")
+        parameters.thinkingType = thinking.type;
+      if (typeof thinking.budgetTokens === "number")
+        parameters.thinkingBudgetTokens = thinking.budgetTokens;
+    }
+    if (request.responseFormat?.type === "jsonSchema") {
+      parameters.schemaVersion = digest(request.responseFormat.schema);
+      parameters.strict = request.responseFormat.strict ?? false;
+    }
+    for (const capability of used) {
+      const observed = { ...parameters };
+      const parts = request.messages.flatMap((message) => message.content).filter((part) => capability === "input.text" ? part.type === "text" || part.type === "json" : capability === `input.${part.type}`);
+      if (capability.startsWith("input."))
+        observed.count = parts.length;
+      const media = parts.filter((part) => part.type === "image" || part.type === "audio" || part.type === "file");
+      if (media.length > 0) {
+        for (const source of ["url", "base64", "file"])
+          observed[`${source}Sources`] = media.filter((part) => part.source.type === source).length;
+        const base64 = media.flatMap((part) => part.source.type === "base64" ? [part.source] : []);
+        const bytes = base64.map((source) => Buffer.byteLength(source.data, "base64"));
+        observed.knownBytesCount = bytes.length;
+        if (bytes.length > 0) {
+          observed.minObservedBytes = Math.min(...bytes);
+          observed.maxObservedBytes = Math.max(...bytes);
+        }
+        observed.mediaTypesVersion = digest([...new Set(base64.map((source) => source.mediaType))].sort());
+      }
+      if (capability === "tools") {
+        observed.definitions = request.tools.length;
+        observed.definitionsVersion = digest(request.tools);
+      }
+      const evidence = !success ? "failed" : capability.startsWith("structuredOutput.") && responseValidated ? "response-validated" : "request-accepted";
+      this.records.push({
+        model: selection.model,
+        adapter: selection.adapter,
+        connectionId: connectionIdentity(selection),
+        capability,
+        observedAt: Date.now(),
+        success,
+        evidence,
+        parameters: observed
+      });
+    }
+    if (this.records.length > this.maxRecords)
+      this.records.splice(0, this.records.length - this.maxRecords);
+  }
+  async discover(selection, refresh, skipReasoning, fields) {
+    const key = `${connectionIdentity(selection)}:${digest({ model: selection.model, fields: [...fields].sort(), skipReasoning })}`;
+    if (refresh)
+      this.cache.delete(key);
+    const cached = this.cache.get(key);
+    if (cached !== void 0 && cached.expiresAt > Date.now()) {
+      this.cache.delete(key);
+      this.cache.set(key, cached);
+      return cached;
+    }
+    this.cache.delete(key);
+    const active = this.pending.get(key);
+    if (active !== void 0)
+      return active;
+    if (this.pending.size >= this.maxEntries)
+      throw new RangeError("Capability discovery concurrency limit exceeded");
+    const operation = this.query(selection, skipReasoning, fields);
+    this.pending.set(key, operation);
+    try {
+      const result = await operation;
+      if (this.pending.get(key) === operation && result.diagnostics.length === 0) {
+        this.cache.set(key, result);
+        while (this.cache.size > this.maxEntries)
+          this.cache.delete(this.cache.keys().next().value);
+      }
+      return result;
+    } finally {
+      if (this.pending.get(key) === operation)
+        this.pending.delete(key);
+    }
+  }
+  async query(selection, skipReasoning, requested) {
+    const fields = {};
+    let reasoningEffort;
+    const diagnostics = [];
+    for (const [index, discovery] of this.discoveries.entries()) {
+      let found;
+      let foundReasoning;
+      try {
+        found = await discovery.discoverCapabilities?.(selection, requested);
+        if (!skipReasoning && reasoningEffort === void 0)
+          foundReasoning = await discovery.discoverReasoningEffort?.(selection);
+      } catch {
+        diagnostics.push({
+          discovery: discovery.name ?? `discovery-${index + 1}`,
+          code: "DISCOVERY_FAILED",
+          observedAt: Date.now()
+        });
+        continue;
+      }
+      if (found !== void 0)
+        assertCapabilityFields(found);
+      if (foundReasoning !== void 0)
+        assertReasoningCapabilities(foundReasoning);
+      if (found !== void 0) {
+        for (const field of requested)
+          if (fields[field] === void 0 && found[field] !== void 0)
+            fields[field] = found[field];
+      }
+      reasoningEffort ??= foundReasoning;
+    }
+    const observedAt = Date.now();
+    return omitUndefined({ fields, reasoningEffort, observedAt, expiresAt: observedAt + this.ttl, diagnostics });
+  }
+};
+function createModelCapabilityResolver(options = {}) {
+  return new ModelCapabilityResolver(options);
+}
+__name(createModelCapabilityResolver, "createModelCapabilityResolver");
+function connectionIdentity(selection) {
+  return digest({ provider: selection.provider, adapter: selection.adapter, config: selection.providerConfig });
+}
+__name(connectionIdentity, "connectionIdentity");
+var UNKNOWN = { status: "unknown", source: "unknown" };
+function known(value, source) {
+  return value === false ? { status: "unsupported", source } : { status: "known", source, value };
+}
+__name(known, "known");
+function declaredFields(overrides, source) {
+  return Object.fromEntries(Object.entries(overrides?.fields ?? {}).map(([field, value]) => [field, known(value, source)]));
+}
+__name(declaredFields, "declaredFields");
+function declaredLimit(selection, field) {
+  if (field !== "contextWindowTokens" && field !== "maxOutputTokens")
+    return void 0;
+  const value = selection.limits?.[field];
+  return value === void 0 ? void 0 : known(value, "user");
+}
+__name(declaredLimit, "declaredLimit");
+function declaredReasoning(overrides, source) {
+  const reasoning = overrides?.reasoning;
+  if (reasoning === void 0)
+    return void 0;
+  if (reasoning === false || reasoning.efforts.length === 0)
+    return { status: "unsupported", source };
+  return omitUndefined({
+    status: "known",
+    source,
+    efforts: [...reasoning.efforts],
+    defaultEffort: reasoning.defaultEffort
+  });
+}
+__name(declaredReasoning, "declaredReasoning");
+function intersectReasoning(model, connection) {
+  if (model.status === "unsupported")
+    return model;
+  if (connection?.status === "unsupported")
+    return connection;
+  if (model.status !== "known" || connection?.status === "unknown")
+    return UNKNOWN;
+  if (connection === void 0)
+    return model;
+  const efforts = model.efforts.filter((effort) => connection.efforts.includes(effort));
+  if (efforts.length === 0)
+    return { status: "unsupported", source: connection.source };
+  const defaultEffort = connection.defaultEffort ?? model.defaultEffort;
+  return {
+    status: "known",
+    source: connection.source,
+    efforts,
+    ...defaultEffort !== void 0 && efforts.includes(defaultEffort) ? { defaultEffort } : {}
+  };
+}
+__name(intersectReasoning, "intersectReasoning");
+function intersectCapability(field, values) {
+  const unsupported = values.find((value2) => value2?.status === "unsupported");
+  if (unsupported !== void 0)
+    return unsupported;
+  if (values.some((value2) => value2?.status === "unknown"))
+    return UNKNOWN;
+  const concrete = values.filter((value2) => value2?.status === "known");
+  if (concrete.length === 0)
+    return UNKNOWN;
+  let value = concrete[0].value;
+  let source = concrete[0].source;
+  for (const next of concrete.slice(1)) {
+    const previous = JSON.stringify(value);
+    if (typeof value === "number" && typeof next.value === "number")
+      value = Math.min(value, next.value);
+    else if (Array.isArray(value) && Array.isArray(next.value))
+      value = value.filter((item) => next.value.includes(item));
+    else if (field === "parameters" || field === "structuredOutput.schemaConstraint")
+      value = { allOf: [value, next.value] };
+    if (JSON.stringify(value) !== previous)
+      source = next.source;
+  }
+  if (Array.isArray(value) && value.length === 0)
+    return { status: "unsupported", source: concrete.at(-1).source };
+  return { status: "known", source, value };
+}
+__name(intersectCapability, "intersectCapability");
+function builtinAdapterCapabilities(adapter) {
+  if (adapter === "google-gemini")
+    return Object.fromEntries(Object.entries({
+      "input.text": true,
+      "input.image": true,
+      "input.audio": true,
+      "input.file": true,
+      "input.resource": false,
+      "input.image.sources": ["url", "base64"],
+      "input.audio.sources": ["url", "base64"],
+      "input.file.sources": ["url", "base64"],
+      "output.text": true,
+      "output.image": true,
+      "output.audio": true,
+      tools: true,
+      "structuredOutput.json": true,
+      "structuredOutput.jsonSchema": true,
+      "structuredOutput.schemaDialects": ["draft-07", "2020-12"],
+      contextCompaction: false,
+      "reasoning.modes": ["effort", "budget"]
+    }).map(([field, value]) => [field, known(value, "adapter")]));
+  if (![
+    "openai-responses",
+    "openai-chat-completions",
+    "deepseek-chat",
+    "kimi-chat",
+    "zhipu-chat",
+    "anthropic-messages"
+  ].includes(adapter))
+    return {};
+  const responses = adapter === "openai-responses";
+  const anthropic = adapter === "anthropic-messages";
+  const openaiChat = adapter === "openai-chat-completions";
+  const values = {
+    "input.text": true,
+    "input.image": true,
+    "input.audio": false,
+    "input.file": responses || anthropic,
+    "input.resource": false,
+    "input.image.sources": responses || anthropic ? ["url", "base64", "file"] : ["url", "base64"],
+    "input.file.sources": responses || anthropic ? ["url", "base64", "file"] : false,
+    "output.text": true,
+    "output.image": responses,
+    "output.audio": false,
+    tools: true,
+    "structuredOutput.json": responses || openaiChat,
+    "structuredOutput.jsonSchema": responses || openaiChat,
+    "structuredOutput.schemaDialects": responses || openaiChat ? ["draft-07", "2020-12"] : false,
+    contextCompaction: responses,
+    "reasoning.modes": anthropic ? ["effort", "budget", "adaptive"] : responses ? ["effort", "summary"] : openaiChat ? ["effort"] : ["effort", "thinking"]
+  };
+  return Object.fromEntries(Object.entries(values).map(([field, value]) => [field, known(value, "adapter")]));
+}
+__name(builtinAdapterCapabilities, "builtinAdapterCapabilities");
+var BUILTIN_REASONING_EFFORTS = new Map([
+  ...["openai-responses", "openai-chat-completions"].flatMap((adapter) => ["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"].map((model) => [
+    catalogKey(adapter, model),
+    { efforts: ["none", "low", "medium", "high", "xhigh", "max"], defaultEffort: "medium" }
+  ])),
+  ...["deepseek-v4-flash", "deepseek-v4-pro", "deepseek-v4-flash-vision-exp"].map((model) => [catalogKey("deepseek-chat", model), { efforts: ["low", "high", "max"], defaultEffort: "high" }])
+]);
+function builtinReasoningEffort(selection) {
+  const entry = BUILTIN_REASONING_EFFORTS.get(catalogKey(selection.adapter, selection.model));
+  return entry === void 0 ? void 0 : omitUndefined({
+    status: "known",
+    source: "builtin",
+    efforts: [...entry.efforts],
+    defaultEffort: entry.defaultEffort
+  });
+}
+__name(builtinReasoningEffort, "builtinReasoningEffort");
+function catalogKey(adapter, model) {
+  return `${adapter}\0${model}`;
+}
+__name(catalogKey, "catalogKey");
+var BEARER_DEFAULT_BASE_URLS = {
+  "openai-responses": "https://api.openai.com/v1",
+  "openai-chat-completions": "https://api.openai.com/v1",
+  "deepseek-chat": "https://api.deepseek.com",
+  "kimi-chat": "https://api.moonshot.ai/v1",
+  "zhipu-chat": "https://open.bigmodel.cn/api/paas/v4"
+};
+function trimBaseURL(value) {
+  return value.replace(/\/+$/u, "");
+}
+__name(trimBaseURL, "trimBaseURL");
+function listEntry(model) {
+  return (body) => Array.isArray(body.models) ? body.models.find((entry) => isRecord(entry) && entry.slug === model) : Array.isArray(body.data) ? body.data.find((entry) => isRecord(entry) && entry.id === model) : void 0;
+}
+__name(listEntry, "listEntry");
+function modelEndpoint(selection) {
+  const { adapter, model, providerConfig, options } = selection;
+  const apiKey = providerConfig.apiKey === void 0 || providerConfig.apiKey.trim() === "" ? void 0 : providerConfig.apiKey;
+  const bearer = BEARER_DEFAULT_BASE_URLS[adapter];
+  if (bearer !== void 0) {
+    return {
+      url: `${trimBaseURL(providerConfig.baseURL ?? bearer)}/models?client_version=may`,
+      headers: apiKey === void 0 ? {} : { Authorization: `Bearer ${apiKey}` },
+      entry: listEntry(model)
+    };
+  }
+  if (adapter === "anthropic-messages") {
+    return {
+      url: `${trimBaseURL(providerConfig.baseURL ?? "https://api.anthropic.com")}/v1/models?limit=1000`,
+      headers: {
+        "anthropic-version": typeof options.apiVersion === "string" ? options.apiVersion : "2023-06-01",
+        ...apiKey === void 0 ? {} : { "x-api-key": apiKey }
+      },
+      entry: listEntry(model)
+    };
+  }
+  if (adapter === "google-gemini") {
+    return {
+      url: `${trimBaseURL(providerConfig.baseURL ?? "https://generativelanguage.googleapis.com/v1beta")}/models/${encodeURIComponent(model)}`,
+      headers: apiKey === void 0 ? {} : { "x-goog-api-key": apiKey },
+      entry: /* @__PURE__ */ __name((body) => body, "entry")
+    };
+  }
+  return void 0;
+}
+__name(modelEndpoint, "modelEndpoint");
+function effortNames(levels) {
+  return [
+    ...new Set(levels.flatMap((level) => {
+      const effort = typeof level === "string" ? level : isRecord(level) ? level.effort : void 0;
+      return typeof effort === "string" && effort.trim() !== "" ? [effort] : [];
+    }))
+  ];
+}
+__name(effortNames, "effortNames");
+function entryReasoningEffort(entry) {
+  const effort = isRecord(entry.effort) ? entry.effort : void 0;
+  const levels = Array.isArray(entry.supported_reasoning_levels) ? entry.supported_reasoning_levels : Array.isArray(entry.reasoning_levels) ? entry.reasoning_levels : Array.isArray(effort?.supported_levels) ? effort.supported_levels : void 0;
+  if (levels === void 0)
+    return entry.thinking === false ? { status: "unsupported", source: "provider" } : void 0;
+  const efforts = effortNames(levels);
+  if (efforts.length === 0)
+    return void 0;
+  const defaultEffort = entry.default_reasoning_level ?? effort?.default_level;
+  return {
+    status: "known",
+    source: "provider",
+    efforts,
+    ...typeof defaultEffort === "string" && efforts.includes(defaultEffort) ? { defaultEffort } : {}
+  };
+}
+__name(entryReasoningEffort, "entryReasoningEffort");
+var ModelListCapabilityDiscovery = class {
+  static {
+    __name(this, "ModelListCapabilityDiscovery");
+  }
+  fetchImplementation;
+  name = "model-list";
+  constructor(fetchImplementation) {
+    this.fetchImplementation = fetchImplementation;
+  }
+  async discoverReasoningEffort(selection) {
+    const endpoint = modelEndpoint(selection);
+    if (endpoint === void 0)
+      return void 0;
+    const response = await this.fetchImplementation(endpoint.url, {
+      signal: AbortSignal.timeout(1e4),
+      headers: endpoint.headers
+    });
+    if (response.status === 404)
+      return void 0;
+    if (!response.ok)
+      throw new Error("Capability catalog request failed");
+    const value = await response.json();
+    if (!isRecord(value))
+      return void 0;
+    const entry = endpoint.entry(value);
+    return isRecord(entry) ? entryReasoningEffort(entry) : void 0;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function assertCapabilityFields(fields) {
+  const declarations = {};
+  for (const [field, capability] of Object.entries(fields)) {
+    if (!MODEL_CAPABILITY_KEYS.includes(field) || !isRecord(capability))
+      throw new TypeError("Invalid discovered capability field");
+    if (capability.status === "unknown" && capability.source === "unknown")
+      continue;
+    if (!["user", "provider", "builtin", "adapter"].includes(String(capability.source)))
+      throw new TypeError("Invalid capability source");
+    if (capability.status === "unsupported")
+      declarations[field] = false;
+    else if (capability.status === "known") {
+      if (capability.value === false)
+        throw new TypeError("False capability declarations require unsupported status");
+      declarations[field] = capability.value;
+    } else
+      throw new TypeError("Invalid capability status");
+  }
+  parseMayConfig({
+    providers: { metadata: { adapter: "metadata" } },
+    models: { metadata: { provider: "metadata", model: "metadata", capabilities: { fields: declarations } } }
+  });
+}
+__name(assertCapabilityFields, "assertCapabilityFields");
+function assertReasoningCapabilities(capability) {
+  if (capability.status === "unknown" && capability.source === "unknown")
+    return;
+  if (!["user", "provider", "builtin", "adapter"].includes(capability.source))
+    throw new TypeError("Invalid reasoning capability source");
+  if (capability.status === "unsupported")
+    return;
+  if (capability.status !== "known")
+    throw new TypeError("Invalid reasoning capability status");
+  parseMayConfig({
+    providers: { metadata: { adapter: "metadata" } },
+    models: {
+      metadata: {
+        provider: "metadata",
+        model: "metadata",
+        capabilities: {
+          reasoning: omitUndefined({ efforts: capability.efforts, defaultEffort: capability.defaultEffort })
+        }
+      }
+    }
+  });
+}
+__name(assertReasoningCapabilities, "assertReasoningCapabilities");
+function digest(value) {
+  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+__name(digest, "digest");
+function positive(value, field) {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new RangeError(`${field} must be a positive safe integer`);
+  return value;
+}
+__name(positive, "positive");
+
+// packages/providers/dist/anthropic/anthropic-model.js
+import { executeRecordedRequest, requestEndpoint } from "@sortedyuan/may/core";
+
+// packages/providers/dist/openai-compatible/http.js
+async function* readSseData(response, signal, protocolError, providerName) {
+  if (!response.body) {
+    throw protocolError(`${providerName} response has no body`);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const dataEvents = [];
+  const parser = createParser({
+    onEvent: /* @__PURE__ */ __name((event) => dataEvents.push(event.data), "onEvent")
+  });
+  const onAbort = /* @__PURE__ */ __name(() => {
+    void reader.cancel(signal.reason).catch(() => void 0);
+  }, "onAbort");
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    while (true) {
+      throwIfAborted(signal);
+      const { done, value } = await reader.read();
+      throwIfAborted(signal);
+      if (done) {
+        parser.feed(`${decoder.decode()}
+
+`);
+      } else {
+        parser.feed(decoder.decode(value, { stream: true }));
+      }
+      for (const data of dataEvents) {
+        throwIfAborted(signal);
+        yield data;
+      }
+      dataEvents.length = 0;
+      if (done)
+        break;
+    }
+    throwIfAborted(signal);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    void reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+__name(readSseData, "readSseData");
+function parseRetryAfterMs(value) {
+  if (value === null)
+    return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.round(seconds * 1e3);
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? Math.max(0, timestamp - Date.now()) : void 0;
+}
+__name(parseRetryAfterMs, "parseRetryAfterMs");
+function throwIfAborted(signal) {
+  if (!signal.aborted)
+    return;
+  if (signal.reason instanceof Error)
+    throw signal.reason;
+  throw new DOMException("The operation was aborted", "AbortError");
+}
+__name(throwIfAborted, "throwIfAborted");
+
+// packages/providers/dist/anthropic/convert.js
+import { UnsupportedContentError } from "@sortedyuan/may/core";
+
+// packages/providers/dist/anthropic/errors.js
+var AnthropicError = class extends Error {
+  static {
+    __name(this, "AnthropicError");
+  }
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    this.code = code;
+  }
+};
+var AnthropicApiError = class extends AnthropicError {
+  static {
+    __name(this, "AnthropicApiError");
+  }
+  status;
+  providerType;
+  requestId;
+  retryAfterMs;
+  constructor(options) {
+    super("ANTHROPIC_API_ERROR", options.message);
+    this.status = options.status;
+    this.providerType = options.providerType;
+    this.requestId = options.requestId;
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+var AnthropicStreamError = class extends AnthropicError {
+  static {
+    __name(this, "AnthropicStreamError");
+  }
+  providerType;
+  requestId;
+  constructor(options) {
+    super("ANTHROPIC_STREAM_ERROR", options.message);
+    this.providerType = options.providerType;
+    this.requestId = options.requestId;
+  }
+};
+var AnthropicProtocolError = class extends AnthropicError {
+  static {
+    __name(this, "AnthropicProtocolError");
+  }
+  constructor(message, options) {
+    super("ANTHROPIC_PROTOCOL_ERROR", message, options);
+  }
+};
+var AnthropicFinishReasonError = class extends AnthropicError {
+  static {
+    __name(this, "AnthropicFinishReasonError");
+  }
+  finishReason;
+  constructor(finishReason) {
+    super("ANTHROPIC_INCOMPLETE_RESPONSE", `Anthropic stopped with finish reason "${finishReason}"`);
+    this.finishReason = finishReason;
+  }
+};
+
+// packages/providers/dist/anthropic/protocol.js
+var ANTHROPIC_MODEL_STATE_TYPE = "@may/provider-anthropic/message-v1";
+
+// packages/providers/dist/anthropic/convert.js
+function toAnthropicRequestParts(messages) {
+  const system = [];
+  const converted = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      const text = serializeVisibleContent(message.content);
+      if (text !== "")
+        system.push(text);
+      continue;
+    }
+    if (message.role === "user") {
+      converted.push({
+        role: "user",
+        content: toUserBlocks(message.content)
+      });
+      continue;
+    }
+    if (message.role === "tool") {
+      const toolResult = {
+        type: "tool_result",
+        tool_use_id: message.toolCallId,
+        content: hasMedia(message.content) ? toUserBlocks(message.content) : serializeVisibleContent(message.content, "tool")
+      };
+      if (message.isError !== void 0) {
+        toolResult.is_error = message.isError;
+      }
+      converted.push({ role: "user", content: [toolResult] });
+      continue;
+    }
+    const nativeContent = getAnthropicStateContent(message.modelState);
+    if (nativeContent !== void 0) {
+      converted.push({ role: "assistant", content: nativeContent });
+      continue;
+    }
+    const content = [...toAssistantTextBlocks(message.content)];
+    for (const call of message.toolCalls ?? []) {
+      if (!isRecord2(call.input)) {
+        throw new AnthropicProtocolError(`Anthropic tool call "${call.name}" input must be an object`);
+      }
+      content.push({
+        type: "tool_use",
+        id: call.id,
+        name: call.name,
+        input: call.input
+      });
+    }
+    converted.push({ role: "assistant", content });
+  }
+  const result = { messages: converted };
+  if (system.length > 0)
+    result.system = system.join("\n");
+  return result;
+}
+__name(toAnthropicRequestParts, "toAnthropicRequestParts");
+function toAnthropicTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  }));
+}
+__name(toAnthropicTools, "toAnthropicTools");
+function toAnthropicThinking(thinking) {
+  if (thinking.type === "enabled") {
+    const converted = {
+      type: "enabled",
+      budget_tokens: thinking.budgetTokens
+    };
+    if (thinking.display !== void 0)
+      converted.display = thinking.display;
+    return converted;
+  }
+  if (thinking.type === "adaptive") {
+    const converted = {
+      type: "adaptive"
+    };
+    if (thinking.display !== void 0)
+      converted.display = thinking.display;
+    return converted;
+  }
+  return { type: "disabled" };
+}
+__name(toAnthropicThinking, "toAnthropicThinking");
+function getAnthropicStateContent(state) {
+  if (state?.type !== ANTHROPIC_MODEL_STATE_TYPE)
+    return void 0;
+  if (!isRecord2(state.data) || !Array.isArray(state.data.content)) {
+    throw new AnthropicProtocolError("Anthropic model state is malformed");
+  }
+  return state.data.content;
+}
+__name(getAnthropicStateContent, "getAnthropicStateContent");
+function toAssistantTextBlocks(content) {
+  return content.flatMap((part) => {
+    if (part.type === "reasoning")
+      return [];
+    if (part.type !== "text" && part.type !== "json") {
+      throw new UnsupportedContentError("Anthropic adapter", part.type, "assistant");
+    }
+    return [
+      {
+        type: "text",
+        text: part.type === "text" ? part.text : serializeJson(part.value)
+      }
+    ];
+  });
+}
+__name(toAssistantTextBlocks, "toAssistantTextBlocks");
+function toUserBlocks(content) {
+  return content.flatMap((part) => {
+    if (part.type === "reasoning")
+      return [];
+    if (part.type === "text")
+      return [{ type: "text", text: part.text }];
+    if (part.type === "json") {
+      return [{ type: "text", text: serializeJson(part.value) }];
+    }
+    if (part.type === "image") {
+      return [{ type: "image", source: toAnthropicSource(part.source) }];
+    }
+    if (part.type === "file") {
+      return [{ type: "document", source: toAnthropicSource(part.source) }];
+    }
+    throw new UnsupportedContentError("Anthropic adapter", part.type, "user");
+  });
+}
+__name(toUserBlocks, "toUserBlocks");
+function serializeVisibleContent(content, role = "system") {
+  return content.filter((part) => part.type !== "reasoning").map((part) => {
+    if (part.type === "text")
+      return part.text;
+    if (part.type === "json")
+      return serializeJson(part.value);
+    throw new UnsupportedContentError("Anthropic adapter", part.type, role);
+  }).join("\n");
+}
+__name(serializeVisibleContent, "serializeVisibleContent");
+function hasMedia(content) {
+  return content.some((part) => part.type === "image" || part.type === "file");
+}
+__name(hasMedia, "hasMedia");
+function toAnthropicSource(source) {
+  if (source.type === "url")
+    return { type: "url", url: source.url };
+  if (source.type === "file")
+    return { type: "file", file_id: source.fileId };
+  return {
+    type: "base64",
+    media_type: source.mediaType,
+    data: source.data
+  };
+}
+__name(toAnthropicSource, "toAnthropicSource");
+function serializeJson(value) {
+  const serialized = JSON.stringify(value);
+  return serialized === void 0 ? "null" : serialized;
+}
+__name(serializeJson, "serializeJson");
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord2, "isRecord");
+
+// packages/providers/dist/anthropic/stream.js
+async function* streamAnthropicResponse(response, signal) {
+  const blocks = /* @__PURE__ */ new Map();
+  let messageId;
+  let sawMessageStart = false;
+  let sawMessageStop = false;
+  let stopReason;
+  let inputTokens;
+  let outputTokens;
+  let cachedReadTokens;
+  let cachedWriteTokens;
+  const usageItems = /* @__PURE__ */ new Map();
+  for await (const data of readSseData(response, signal, (message2, options) => new AnthropicProtocolError(message2, options), "Anthropic")) {
+    const event = parseEvent(data);
+    if (event.type === "ping")
+      continue;
+    if (event.type === "error")
+      throw createStreamError(event);
+    if (event.type === "message_start") {
+      if (sawMessageStart) {
+        throw new AnthropicProtocolError("Anthropic emitted more than one message_start event");
+      }
+      const message2 = requireRecord(event.message, "message_start.message");
+      messageId = requireString(message2.id, "message_start.message.id");
+      const usage2 = optionalRecord(message2.usage);
+      inputTokens = optionalTokenCount(usage2?.input_tokens);
+      outputTokens = optionalTokenCount(usage2?.output_tokens);
+      cachedReadTokens = optionalTokenCount(usage2?.cache_read_input_tokens);
+      cachedWriteTokens = optionalTokenCount(usage2?.cache_creation_input_tokens);
+      collectUsageItems(usage2, usageItems);
+      sawMessageStart = true;
+      continue;
+    }
+    if (event.type === "content_block_start") {
+      requireActiveMessage(sawMessageStart, sawMessageStop);
+      const index = requireIndex(event.index);
+      if (blocks.has(index)) {
+        throw new AnthropicProtocolError(`Anthropic started content block ${index} more than once`);
+      }
+      blocks.set(index, createPendingBlock(event.content_block, index));
+      continue;
+    }
+    if (event.type === "content_block_delta") {
+      requireActiveMessage(sawMessageStart, sawMessageStop);
+      const index = requireIndex(event.index);
+      const block = requirePendingBlock(blocks, index);
+      const delta = requireRecord(event.delta, `content block ${index} delta`);
+      const deltaType = requireString(delta.type, `content block ${index} delta.type`);
+      if (deltaType === "text_delta") {
+        if (block.kind !== "text")
+          throw mismatchedDelta(index, deltaType);
+        const text = requireString(delta.text, `content block ${index} text`);
+        block.block.text += text;
+        if (text !== "")
+          yield { type: "text.delta", delta: text };
+        continue;
+      }
+      if (deltaType === "thinking_delta") {
+        if (block.kind !== "thinking")
+          throw mismatchedDelta(index, deltaType);
+        const thinking = requireString(delta.thinking, `content block ${index} thinking`);
+        block.block.thinking += thinking;
+        if (thinking !== "") {
+          yield { type: "reasoning.delta", delta: thinking };
+        }
+        continue;
+      }
+      if (deltaType === "signature_delta") {
+        if (block.kind !== "thinking")
+          throw mismatchedDelta(index, deltaType);
+        block.block.signature += requireString(delta.signature, `content block ${index} signature`);
+        continue;
+      }
+      if (deltaType === "input_json_delta") {
+        if (block.kind !== "tool_use")
+          throw mismatchedDelta(index, deltaType);
+        block.partialJson += requireString(delta.partial_json, `content block ${index} partial_json`);
+      }
+      continue;
+    }
+    if (event.type === "content_block_stop") {
+      requireActiveMessage(sawMessageStart, sawMessageStop);
+      const index = requireIndex(event.index);
+      const block = requirePendingBlock(blocks, index);
+      if (block.kind === "tool_use" && block.partialJson.trim() !== "") {
+        block.block.input = parseToolInput(block.partialJson, index);
+      }
+      block.stopped = true;
+      continue;
+    }
+    if (event.type === "message_delta") {
+      requireActiveMessage(sawMessageStart, sawMessageStop);
+      const delta = requireRecord(event.delta, "message_delta.delta");
+      if (delta.stop_reason !== void 0 && delta.stop_reason !== null) {
+        stopReason = requireString(delta.stop_reason, "message_delta.delta.stop_reason");
+      }
+      const usage2 = optionalRecord(event.usage);
+      inputTokens = optionalTokenCount(usage2?.input_tokens) ?? inputTokens;
+      outputTokens = optionalTokenCount(usage2?.output_tokens) ?? outputTokens;
+      cachedReadTokens = optionalTokenCount(usage2?.cache_read_input_tokens) ?? cachedReadTokens;
+      cachedWriteTokens = optionalTokenCount(usage2?.cache_creation_input_tokens) ?? cachedWriteTokens;
+      collectUsageItems(usage2, usageItems);
+      continue;
+    }
+    if (event.type === "message_stop") {
+      requireActiveMessage(sawMessageStart, sawMessageStop);
+      sawMessageStop = true;
+    }
+  }
+  if (!sawMessageStart || messageId === void 0) {
+    throw new AnthropicProtocolError("Anthropic stream ended without a message_start event");
+  }
+  if (!sawMessageStop) {
+    throw new AnthropicProtocolError("Anthropic stream ended without a message_stop event");
+  }
+  if (stopReason === void 0) {
+    throw new AnthropicProtocolError("Anthropic stream ended without a stop_reason");
+  }
+  if (stopReason !== "end_turn" && stopReason !== "tool_use") {
+    throw new AnthropicFinishReasonError(stopReason);
+  }
+  const content = [...blocks.entries()].sort(([left], [right]) => left - right).map(([index, block]) => {
+    if (!block.stopped) {
+      throw new AnthropicProtocolError(`Anthropic content block ${index} did not stop`);
+    }
+    return block.block;
+  });
+  const message = toAssistantMessage(messageId, content);
+  const calls = message.toolCalls ?? [];
+  if (stopReason === "tool_use" && calls.length === 0) {
+    throw new AnthropicProtocolError("Anthropic stopped for tool_use but emitted no tool calls");
+  }
+  if (stopReason !== "tool_use" && calls.length > 0) {
+    throw new AnthropicProtocolError(`Anthropic emitted tool calls with stop reason "${stopReason}"`);
+  }
+  const completed = {
+    type: "response.completed",
+    message
+  };
+  const usage = createUsage(inputTokens, outputTokens, cachedReadTokens, cachedWriteTokens, [...usageItems.values()]);
+  if (usage !== void 0)
+    completed.usage = usage;
+  yield completed;
+}
+__name(streamAnthropicResponse, "streamAnthropicResponse");
+function parseEvent(data) {
+  try {
+    const event = JSON.parse(data);
+    const record = requireRecord(event, "stream event");
+    requireString(record.type, "stream event.type");
+    return record;
+  } catch (error) {
+    if (error instanceof AnthropicProtocolError)
+      throw error;
+    throw new AnthropicProtocolError("Anthropic emitted invalid SSE JSON", { cause: error });
+  }
+}
+__name(parseEvent, "parseEvent");
+function createPendingBlock(value, index) {
+  const block = requireRecord(value, `content block ${index}`);
+  const type = requireString(block.type, `content block ${index}.type`);
+  if (type === "text") {
+    return {
+      kind: "text",
+      stopped: false,
+      block: {
+        type,
+        text: requireString(block.text, `content block ${index}.text`)
+      }
+    };
+  }
+  if (type === "thinking") {
+    return {
+      kind: "thinking",
+      stopped: false,
+      block: {
+        type,
+        thinking: requireString(block.thinking, `content block ${index}.thinking`),
+        signature: requireString(block.signature, `content block ${index}.signature`)
+      }
+    };
+  }
+  if (type === "redacted_thinking") {
+    return {
+      kind: "redacted_thinking",
+      stopped: false,
+      block: {
+        type,
+        data: requireString(block.data, `content block ${index}.data`)
+      }
+    };
+  }
+  if (type === "tool_use") {
+    return {
+      kind: "tool_use",
+      stopped: false,
+      partialJson: "",
+      block: {
+        type,
+        id: requireString(block.id, `content block ${index}.id`),
+        name: requireString(block.name, `content block ${index}.name`),
+        input: requireObject(block.input, `content block ${index}.input`)
+      }
+    };
+  }
+  throw new AnthropicProtocolError(`Anthropic emitted unsupported content block type "${type}"`);
+}
+__name(createPendingBlock, "createPendingBlock");
+function toAssistantMessage(messageId, blocks) {
+  const message = {
+    role: "assistant",
+    content: [],
+    modelState: {
+      type: ANTHROPIC_MODEL_STATE_TYPE,
+      data: { messageId, content: blocks }
+    }
+  };
+  const calls = [];
+  for (const block of blocks) {
+    if (block.type === "thinking") {
+      message.content.push({ type: "reasoning", text: block.thinking });
+    } else if (block.type === "text") {
+      if (block.text !== "") {
+        message.content.push({ type: "text", text: block.text });
+      }
+    } else if (block.type === "tool_use") {
+      calls.push({ id: block.id, name: block.name, input: block.input });
+    }
+  }
+  if (calls.length > 0)
+    message.toolCalls = calls;
+  return message;
+}
+__name(toAssistantMessage, "toAssistantMessage");
+function createStreamError(event) {
+  const error = optionalRecord(event.error);
+  const providerType = optionalString(error?.type);
+  const requestId = optionalString(event.request_id);
+  const message = optionalString(error?.message) ?? "Anthropic stream failed";
+  const options = {
+    message
+  };
+  if (providerType !== void 0)
+    options.providerType = providerType;
+  if (requestId !== void 0)
+    options.requestId = requestId;
+  return new AnthropicStreamError(options);
+}
+__name(createStreamError, "createStreamError");
+function parseToolInput(input, index) {
+  try {
+    return requireObject(JSON.parse(input), `content block ${index} tool input`);
+  } catch (error) {
+    if (error instanceof AnthropicProtocolError)
+      throw error;
+    throw new AnthropicProtocolError(`Anthropic emitted invalid tool input JSON at content block ${index}`, {
+      cause: error
+    });
+  }
+}
+__name(parseToolInput, "parseToolInput");
+function requireActiveMessage(started, stopped) {
+  if (!started) {
+    throw new AnthropicProtocolError("Anthropic emitted content before message_start");
+  }
+  if (stopped) {
+    throw new AnthropicProtocolError("Anthropic emitted content after message_stop");
+  }
+}
+__name(requireActiveMessage, "requireActiveMessage");
+function requirePendingBlock(blocks, index) {
+  const block = blocks.get(index);
+  if (!block) {
+    throw new AnthropicProtocolError(`Anthropic referenced unknown content block ${index}`);
+  }
+  if (block.stopped) {
+    throw new AnthropicProtocolError(`Anthropic emitted a delta after content block ${index} stopped`);
+  }
+  return block;
+}
+__name(requirePendingBlock, "requirePendingBlock");
+function mismatchedDelta(index, deltaType) {
+  return new AnthropicProtocolError(`Anthropic emitted ${deltaType} for incompatible content block ${index}`);
+}
+__name(mismatchedDelta, "mismatchedDelta");
+function requireRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new AnthropicProtocolError(`Anthropic ${name} must be an object`);
+  }
+  return value;
+}
+__name(requireRecord, "requireRecord");
+function requireObject(value, name) {
+  return requireRecord(value, name);
+}
+__name(requireObject, "requireObject");
+function optionalRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+__name(optionalRecord, "optionalRecord");
+function requireString(value, name) {
+  if (typeof value !== "string") {
+    throw new AnthropicProtocolError(`Anthropic ${name} must be a string`);
+  }
+  return value;
+}
+__name(requireString, "requireString");
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+__name(optionalString, "optionalString");
+function requireIndex(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new AnthropicProtocolError("Anthropic content block index must be a non-negative safe integer");
+  }
+  return value;
+}
+__name(requireIndex, "requireIndex");
+function optionalTokenCount(value) {
+  if (value === void 0)
+    return void 0;
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new AnthropicProtocolError("Anthropic usage token count must be a non-negative safe integer");
+  return value;
+}
+__name(optionalTokenCount, "optionalTokenCount");
+function createUsage(inputTokens, outputTokens, cachedReadTokens, cachedWriteTokens, items) {
+  if (inputTokens === void 0 && outputTokens === void 0 && cachedReadTokens === void 0 && cachedWriteTokens === void 0)
+    return void 0;
+  const usage = {};
+  if (inputTokens !== void 0)
+    usage.inputTokens = inputTokens;
+  if (outputTokens !== void 0)
+    usage.outputTokens = outputTokens;
+  if (cachedReadTokens !== void 0)
+    usage.cachedReadTokens = cachedReadTokens;
+  if (cachedWriteTokens !== void 0)
+    usage.cachedWriteTokens = cachedWriteTokens;
+  if (items.length > 0)
+    usage.items = items;
+  if (cachedReadTokens !== void 0 || cachedWriteTokens !== void 0)
+    usage.tokenRelations = {
+      ...cachedReadTokens === void 0 ? {} : { cachedRead: "total" },
+      ...cachedWriteTokens === void 0 ? {} : { cachedWrite: "total" }
+    };
+  if (inputTokens !== void 0 && outputTokens !== void 0) {
+    usage.totalTokens = inputTokens + outputTokens + (cachedReadTokens ?? 0) + (cachedWriteTokens ?? 0);
+  }
+  if (inputTokens === void 0 || outputTokens === void 0)
+    usage.completeness = { status: "partial", reason: "provider-token-components-missing" };
+  return usage;
+}
+__name(createUsage, "createUsage");
+function collectUsageItems(usage, items) {
+  if (usage === void 0)
+    return;
+  const cache = usage.cache_creation === void 0 || usage.cache_creation === null ? void 0 : requireRecord(usage.cache_creation, "usage.cache_creation");
+  for (const [field, id] of [
+    ["ephemeral_5m_input_tokens", "cache-write-5m"],
+    ["ephemeral_1h_input_tokens", "cache-write-1h"]
+  ]) {
+    const quantity = optionalTokenCount(cache?.[field]);
+    if (quantity !== void 0)
+      items.set(id, { id, quantity, unit: "tokens", includedIn: "cachedWrite" });
+  }
+  const server = usage.server_tool_use === void 0 || usage.server_tool_use === null ? void 0 : requireRecord(usage.server_tool_use, "usage.server_tool_use");
+  for (const [field, id] of [
+    ["web_search_requests", "web-search"],
+    ["web_fetch_requests", "web-fetch"]
+  ]) {
+    const quantity = optionalTokenCount(server?.[field]);
+    if (quantity !== void 0)
+      items.set(id, { id, quantity, unit: "requests", includedIn: "none" });
+  }
+}
+__name(collectUsageItems, "collectUsageItems");
+
+// packages/providers/dist/anthropic/anthropic-model.js
+var FILES_API_BETA = "files-api-2025-04-14";
+var AnthropicModel = class {
+  static {
+    __name(this, "AnthropicModel");
+  }
+  supportsRequestRecording = true;
+  apiKey;
+  promptCaching;
+  model;
+  baseURL;
+  apiVersion;
+  maxTokens;
+  thinking;
+  reasoningEffort;
+  fetchImplementation;
+  constructor(options) {
+    if (options.apiKey.trim() === "") {
+      throw new TypeError("apiKey must not be empty");
+    }
+    if (options.model.trim() === "") {
+      throw new TypeError("model must not be empty");
+    }
+    const maxTokens = options.maxTokens ?? 4096;
+    if (!Number.isSafeInteger(maxTokens) || maxTokens < 1) {
+      throw new RangeError("maxTokens must be a positive safe integer");
+    }
+    if (options.apiVersion !== void 0 && options.apiVersion.trim() === "") {
+      throw new TypeError("apiVersion must not be empty");
+    }
+    if (options.thinking?.type === "enabled") {
+      if (!Number.isSafeInteger(options.thinking.budgetTokens) || options.thinking.budgetTokens < 1024) {
+        throw new RangeError("thinking.budgetTokens must be a safe integer of at least 1024");
+      }
+      if (options.thinking.budgetTokens >= maxTokens) {
+        throw new RangeError("thinking.budgetTokens must be less than maxTokens");
+      }
+    }
+    this.apiKey = options.apiKey;
+    if (options.promptCaching !== void 0 && options.promptCaching !== false) {
+      if (typeof options.promptCaching !== "object" || options.promptCaching === null || Array.isArray(options.promptCaching)) {
+        throw new TypeError("promptCaching must be false or an object");
+      }
+      if (options.promptCaching.ttl !== void 0 && !["5m", "1h"].includes(options.promptCaching.ttl)) {
+        throw new TypeError("promptCaching.ttl must be 5m or 1h");
+      }
+      if (options.promptCaching.cacheInstructions !== void 0 && typeof options.promptCaching.cacheInstructions !== "boolean") {
+        throw new TypeError("promptCaching.cacheInstructions must be a boolean");
+      }
+    }
+    this.promptCaching = options.promptCaching === void 0 || options.promptCaching === false ? options.promptCaching : { ...options.promptCaching };
+    this.model = options.model;
+    this.baseURL = (options.baseURL ?? "https://api.anthropic.com").replace(/\/+$/, "");
+    this.apiVersion = options.apiVersion ?? "2023-06-01";
+    this.maxTokens = maxTokens;
+    this.thinking = cloneThinking(options.thinking);
+    this.reasoningEffort = options.reasoningEffort;
+    this.fetchImplementation = options.fetch ?? globalThis.fetch;
+  }
+  async *stream(request, options) {
+    if (request.responseFormat !== void 0)
+      throw new TypeError("Anthropic adapter does not support responseFormat");
+    const body = this.createRequest(request);
+    yield* executeRecordedRequest({
+      version: 1,
+      adapter: "anthropic-messages",
+      purpose: "generation",
+      endpoint: requestEndpoint(`${this.baseURL}/v1/messages`),
+      request,
+      body,
+      protocol: {
+        "anthropic-version": this.apiVersion,
+        ...usesFileId(request.messages) ? { "anthropic-beta": FILES_API_BETA } : {}
+      }
+    }, options.recordRequest, options.signal, (body2) => this.execute(body2, request, options));
+  }
+  async *execute(body, request, options) {
+    const headers = {
+      "anthropic-version": this.apiVersion,
+      "content-type": "application/json",
+      "x-api-key": this.apiKey
+    };
+    if (usesFileId(request.messages)) {
+      headers["anthropic-beta"] = FILES_API_BETA;
+    }
+    const response = await this.fetchImplementation(`${this.baseURL}/v1/messages`, {
+      method: "POST",
+      headers,
+      body,
+      signal: options.signal
+    });
+    if (!response.ok)
+      throw await createApiError(response);
+    yield* streamAnthropicResponse(response, options.signal);
+  }
+  createRequest(request) {
+    const parts = toAnthropicRequestParts(request.messages);
+    const body = {
+      model: this.model,
+      max_tokens: this.maxTokens,
+      messages: parts.messages,
+      stream: true
+    };
+    if (parts.system !== void 0)
+      body.system = parts.system;
+    if (request.tools.length > 0) {
+      body.tools = toAnthropicTools(request.tools);
+    }
+    if (this.promptCaching) {
+      const cacheControl = { type: "ephemeral", ttl: this.promptCaching.ttl ?? "5m" };
+      body.cache_control = cacheControl;
+      if (this.promptCaching.cacheInstructions) {
+        if (parts.system !== void 0)
+          body.system = [{ type: "text", text: parts.system, cache_control: cacheControl }];
+        const lastTool = body.tools?.at(-1);
+        if (lastTool)
+          lastTool.cache_control = cacheControl;
+      }
+    }
+    if (this.thinking !== void 0) {
+      body.thinking = toAnthropicThinking(this.thinking);
+    }
+    if (this.reasoningEffort !== void 0) {
+      body.output_config = { effort: this.reasoningEffort };
+    }
+    return body;
+  }
+};
+function usesFileId(messages) {
+  return messages.some((message) => message.content.some((part) => (part.type === "image" || part.type === "file") && part.source.type === "file"));
+}
+__name(usesFileId, "usesFileId");
+function cloneThinking(thinking) {
+  return thinking === void 0 ? void 0 : { ...thinking };
+}
+__name(cloneThinking, "cloneThinking");
+async function createApiError(response) {
+  const text = await response.text();
+  let message = text || `Anthropic request failed with status ${response.status}`;
+  let providerType;
+  let requestId = response.headers.get("request-id") ?? void 0;
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed.error?.message === "string") {
+      message = parsed.error.message;
+    }
+    if (typeof parsed.error?.type === "string") {
+      providerType = parsed.error.type;
+    }
+    if (typeof parsed.request_id === "string") {
+      requestId = parsed.request_id;
+    }
+  } catch {
+  }
+  const options = {
+    status: response.status,
+    message
+  };
+  if (providerType !== void 0)
+    options.providerType = providerType;
+  if (requestId !== void 0)
+    options.requestId = requestId;
+  const retryAfterMs2 = parseRetryAfterMs(response.headers.get("retry-after"));
+  if (retryAfterMs2 !== void 0)
+    options.retryAfterMs = retryAfterMs2;
+  return new AnthropicApiError(options);
+}
+__name(createApiError, "createApiError");
+
+// packages/providers/dist/deepseek/index.js
+import { omitUndefined as omitUndefined4 } from "@sortedyuan/may/core";
+
+// packages/providers/dist/openai-compatible/chat-model.js
+import { assertModelResponseFormat, executeRecordedRequest as executeRecordedRequest2, omitUndefined as omitUndefined3, requestEndpoint as requestEndpoint2, validateStructuredModelResponse } from "@sortedyuan/may/core";
+
+// packages/providers/dist/openai-compatible/convert.js
+import { UnsupportedContentError as UnsupportedContentError2, omitUndefined as omitUndefined2 } from "@sortedyuan/may/core";
+function toOpenAICompatibleMessages(messages, options = {}) {
+  return messages.map((message) => {
+    if (message.role === "system") {
+      return {
+        role: "system",
+        content: serializeVisibleContent2(message.content, "system")
+      };
+    }
+    if (message.role === "user") {
+      return { role: "user", content: toUserContent(message.content) };
+    }
+    if (message.role === "tool") {
+      const converted2 = {
+        role: "tool",
+        tool_call_id: message.toolCallId,
+        content: serializeVisibleContent2(message.content, "tool")
+      };
+      if (options.includeToolName)
+        converted2.name = message.name;
+      return converted2;
+    }
+    const converted = {
+      role: "assistant",
+      content: serializeVisibleContent2(message.content, "assistant")
+    };
+    const reasoningParts = message.content.filter((part) => part.type === "reasoning");
+    if (reasoningParts.length > 0) {
+      converted.reasoning_content = reasoningParts.map((part) => part.text).join("");
+    }
+    if (message.toolCalls !== void 0) {
+      converted.tool_calls = message.toolCalls.map(convertToolCall);
+    }
+    return converted;
+  });
+}
+__name(toOpenAICompatibleMessages, "toOpenAICompatibleMessages");
+function toOpenAICompatibleTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }));
+}
+__name(toOpenAICompatibleTools, "toOpenAICompatibleTools");
+function convertToolCall(call) {
+  return {
+    id: call.id,
+    type: "function",
+    function: {
+      name: call.name,
+      arguments: serializeJson2(call.input)
+    }
+  };
+}
+__name(convertToolCall, "convertToolCall");
+function toUserContent(content) {
+  const hasImages = content.some((part) => part.type === "image");
+  if (!hasImages)
+    return serializeVisibleContent2(content, "user");
+  return content.flatMap((part) => {
+    if (part.type === "reasoning")
+      return [];
+    if (part.type === "text")
+      return [{ type: "text", text: part.text }];
+    if (part.type === "json") {
+      return [{ type: "text", text: serializeJson2(part.value) }];
+    }
+    if (part.type === "image") {
+      const imageUrl = imageSourceUrl(part.source);
+      return [
+        {
+          type: "image_url",
+          image_url: omitUndefined2({ url: imageUrl, detail: part.detail })
+        }
+      ];
+    }
+    throw new UnsupportedContentError2("OpenAI-compatible chat adapter", part.type, "user");
+  });
+}
+__name(toUserContent, "toUserContent");
+function serializeVisibleContent2(content, role) {
+  return content.filter((part) => part.type !== "reasoning").map((part) => {
+    if (part.type === "text")
+      return part.text;
+    if (part.type === "json")
+      return serializeJson2(part.value);
+    throw new UnsupportedContentError2("OpenAI-compatible chat adapter", part.type, role);
+  }).join("\n");
+}
+__name(serializeVisibleContent2, "serializeVisibleContent");
+function imageSourceUrl(source) {
+  if (source.type === "url")
+    return source.url;
+  if (source.type === "base64") {
+    return `data:${source.mediaType};base64,${source.data}`;
+  }
+  throw new UnsupportedContentError2("OpenAI-compatible chat adapter", "image file-id source", "user");
+}
+__name(imageSourceUrl, "imageSourceUrl");
+function serializeJson2(value) {
+  const serialized = JSON.stringify(value);
+  return serialized === void 0 ? "null" : serialized;
+}
+__name(serializeJson2, "serializeJson");
+
+// packages/providers/dist/openai-compatible/errors.js
+var OpenAICompatibleError = class extends Error {
+  static {
+    __name(this, "OpenAICompatibleError");
+  }
+  code;
+  provider;
+  constructor(provider, code, message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    this.provider = provider;
+    this.code = code;
+  }
+};
+var OpenAICompatibleApiError = class extends OpenAICompatibleError {
+  static {
+    __name(this, "OpenAICompatibleApiError");
+  }
+  status;
+  providerType;
+  providerCode;
+  retryAfterMs;
+  constructor(provider, codePrefix, options) {
+    super(provider, `${codePrefix}_API_ERROR`, options.message);
+    this.status = options.status;
+    this.providerType = options.providerType;
+    this.providerCode = options.providerCode;
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+var OpenAICompatibleProtocolError = class extends OpenAICompatibleError {
+  static {
+    __name(this, "OpenAICompatibleProtocolError");
+  }
+  constructor(provider, codePrefix, message, options) {
+    super(provider, `${codePrefix}_PROTOCOL_ERROR`, message, options);
+  }
+};
+var OpenAICompatibleFinishReasonError = class extends OpenAICompatibleError {
+  static {
+    __name(this, "OpenAICompatibleFinishReasonError");
+  }
+  finishReason;
+  constructor(provider, codePrefix, finishReason) {
+    super(provider, `${codePrefix}_INCOMPLETE_RESPONSE`, `${provider} stopped with finish reason "${finishReason}"`);
+    this.finishReason = finishReason;
+  }
+};
+
+// packages/providers/dist/openai-compatible/stream.js
+async function* streamOpenAICompatibleResponse(response, options) {
+  let text = "";
+  let reasoning = "";
+  let hasReasoningContent = false;
+  let usage;
+  let finishReason;
+  let receivedDone = false;
+  const pendingCalls = /* @__PURE__ */ new Map();
+  for await (const data of readSseData(response, options.signal, options.protocolError, options.providerName)) {
+    if (data === "[DONE]") {
+      receivedDone = true;
+      break;
+    }
+    const chunk = parseChunk(data, options);
+    if (chunk.error !== void 0) {
+      throw options.protocolError(`${options.providerName} stream reported an error: ${describeStreamError(chunk.error)}`);
+    }
+    if (chunk.usage)
+      usage = convertUsage(chunk.usage, options);
+    for (const choice of chunk.choices ?? []) {
+      if (choice.index !== 0)
+        continue;
+      const delta = choice.delta;
+      if (typeof delta?.reasoning_content === "string") {
+        hasReasoningContent = true;
+        if (delta.reasoning_content !== "") {
+          reasoning += delta.reasoning_content;
+          yield { type: "reasoning.delta", delta: delta.reasoning_content };
+        }
+      }
+      if (delta?.content) {
+        text += delta.content;
+        yield { type: "text.delta", delta: delta.content };
+      }
+      if (delta?.refusal) {
+        text += delta.refusal;
+        yield { type: "text.delta", delta: delta.refusal };
+      }
+      for (const toolDelta of delta?.tool_calls ?? []) {
+        mergeToolCall(pendingCalls, toolDelta);
+      }
+      if (choice.finish_reason !== null && choice.finish_reason !== void 0) {
+        finishReason = choice.finish_reason;
+      }
+    }
+  }
+  if (options.requireDone && !receivedDone) {
+    throw options.protocolError(`${options.providerName} stream ended without [DONE]`);
+  }
+  if (finishReason === void 0) {
+    throw options.protocolError(`${options.providerName} stream ended without a finish_reason`);
+  }
+  if (finishReason !== "stop" && finishReason !== "tool_calls") {
+    throw options.finishReasonError(finishReason);
+  }
+  const toolCalls = completeToolCalls(pendingCalls, options);
+  if (finishReason === "tool_calls" && toolCalls.length === 0) {
+    throw options.protocolError(`${options.providerName} finished with tool_calls but emitted no tool calls`);
+  }
+  const message = { role: "assistant", content: [] };
+  if (hasReasoningContent) {
+    message.content.push({ type: "reasoning", text: reasoning });
+  }
+  if (text !== "")
+    message.content.push({ type: "text", text });
+  if (toolCalls.length > 0)
+    message.toolCalls = toolCalls;
+  const completed = {
+    type: "response.completed",
+    message
+  };
+  if (usage !== void 0)
+    completed.usage = usage;
+  yield completed;
+}
+__name(streamOpenAICompatibleResponse, "streamOpenAICompatibleResponse");
+function parseChunk(data, options) {
+  try {
+    const value = JSON.parse(data);
+    if (typeof value !== "object" || value === null) {
+      throw new TypeError("chunk is not an object");
+    }
+    return value;
+  } catch (error) {
+    throw options.protocolError(`${options.providerName} emitted invalid SSE JSON`, { cause: error });
+  }
+}
+__name(parseChunk, "parseChunk");
+function describeStreamError(error) {
+  if (typeof error === "string") {
+    return error.trim() === "" ? "an empty error string" : error;
+  }
+  if (typeof error === "number" || typeof error === "boolean") {
+    return `a ${typeof error} error value ${String(error)}`;
+  }
+  if (error === null)
+    return "a null error value";
+  if (Array.isArray(error))
+    return "an array error value";
+  if (typeof error !== "object")
+    return `an unsupported ${typeof error} error value`;
+  const payload = error;
+  const details = [];
+  const message = readText(payload.message);
+  const type = readText(payload.type);
+  const code = readText(payload.code) ?? readNumber(payload.code);
+  if (message !== void 0)
+    details.push(message);
+  if (type !== void 0)
+    details.push(`type: ${type}`);
+  if (code !== void 0)
+    details.push(`code: ${code}`);
+  if (details.length === 0)
+    return "an error object without message, type, or code";
+  return details.join(" ");
+}
+__name(describeStreamError, "describeStreamError");
+function readText(value) {
+  if (typeof value !== "string")
+    return void 0;
+  return value.trim() === "" ? void 0 : value;
+}
+__name(readText, "readText");
+function readNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return void 0;
+  return String(value);
+}
+__name(readNumber, "readNumber");
+function mergeToolCall(calls, delta) {
+  const call = calls.get(delta.index) ?? { id: "", name: "", arguments: "" };
+  if (delta.id !== void 0)
+    call.id = delta.id;
+  if (delta.function?.name !== void 0)
+    call.name += delta.function.name;
+  if (delta.function?.arguments !== void 0) {
+    call.arguments += delta.function.arguments;
+  }
+  calls.set(delta.index, call);
+}
+__name(mergeToolCall, "mergeToolCall");
+function completeToolCalls(calls, options) {
+  return [...calls.entries()].sort(([left], [right]) => left - right).map(([index, call]) => {
+    if (call.id === "" || call.name === "") {
+      throw options.protocolError(`${options.providerName} emitted an incomplete tool call at index ${index}`);
+    }
+    return {
+      id: call.id,
+      name: call.name,
+      input: parseToolInput2(call.arguments, options)
+    };
+  });
+}
+__name(completeToolCalls, "completeToolCalls");
+function parseToolInput2(input, options) {
+  if (input === "")
+    return {};
+  try {
+    return JSON.parse(input);
+  } catch {
+    throw options.protocolError(`${options.providerName} emitted invalid tool argument JSON`);
+  }
+}
+__name(parseToolInput2, "parseToolInput");
+function convertUsage(usage, options) {
+  const converted = {};
+  const token = /* @__PURE__ */ __name((value, field) => {
+    if (value === void 0)
+      return void 0;
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw options.protocolError(`${options.providerName} usage.${field} must be a non-negative safe integer`);
+    return value;
+  }, "token");
+  if (usage.prompt_tokens !== void 0) {
+    converted.inputTokens = token(usage.prompt_tokens, "prompt_tokens");
+  }
+  if (usage.completion_tokens !== void 0) {
+    converted.outputTokens = token(usage.completion_tokens, "completion_tokens");
+  }
+  if (usage.total_tokens !== void 0) {
+    converted.totalTokens = token(usage.total_tokens, "total_tokens");
+  }
+  const cachedReadTokens = token(usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens, "cached_tokens");
+  const cachedWriteTokens = token(usage.prompt_tokens_details?.cache_write_tokens, "cache_write_tokens");
+  const reasoningTokens = token(usage.completion_tokens_details?.reasoning_tokens, "reasoning_tokens");
+  if (cachedReadTokens !== void 0)
+    converted.cachedReadTokens = cachedReadTokens;
+  if (cachedWriteTokens !== void 0)
+    converted.cachedWriteTokens = cachedWriteTokens;
+  if (reasoningTokens !== void 0)
+    converted.reasoningTokens = reasoningTokens;
+  if (cachedReadTokens !== void 0 || cachedWriteTokens !== void 0 || reasoningTokens !== void 0)
+    converted.tokenRelations = {
+      ...cachedReadTokens === void 0 ? {} : { cachedRead: "input" },
+      ...cachedWriteTokens === void 0 ? {} : { cachedWrite: "input" },
+      ...reasoningTokens === void 0 ? {} : { reasoning: "output" }
+    };
+  const items = [];
+  const cachedMiss = token(usage.prompt_cache_miss_tokens, "prompt_cache_miss_tokens");
+  if (cachedMiss !== void 0 && cachedReadTokens !== void 0 && converted.inputTokens !== void 0 && cachedReadTokens + cachedMiss !== converted.inputTokens)
+    throw options.protocolError(`${options.providerName} cache token counts do not match prompt_tokens`);
+  for (const [id, value] of [
+    ["input-audio", usage.prompt_tokens_details?.audio_tokens],
+    ["output-audio", usage.completion_tokens_details?.audio_tokens]
+  ]) {
+    const quantity = token(value, id);
+    if (quantity !== void 0 && quantity > 0)
+      items.push({ id, quantity, unit: "tokens", includedIn: id === "input-audio" ? "input" : "output" });
+  }
+  if (items.length > 0)
+    converted.items = items;
+  if (converted.inputTokens === void 0 || converted.outputTokens === void 0)
+    converted.completeness = { status: "partial", reason: "provider-token-components-missing" };
+  return converted;
+}
+__name(convertUsage, "convertUsage");
+
+// packages/providers/dist/openai-compatible/chat-model.js
+var OpenAICompatibleChatModel = class {
+  static {
+    __name(this, "OpenAICompatibleChatModel");
+  }
+  dialect;
+  supportsRequestRecording = true;
+  apiKey;
+  model;
+  baseURL;
+  maxOutputTokens;
+  reasoningEffort;
+  fetchImplementation;
+  constructor(options, dialect) {
+    this.dialect = dialect;
+    if (options.apiKey.trim() === "")
+      throw new TypeError("apiKey must not be empty");
+    if (options.model.trim() === "")
+      throw new TypeError("model must not be empty");
+    if (options.maxOutputTokens !== void 0 && (!Number.isSafeInteger(options.maxOutputTokens) || options.maxOutputTokens < 1)) {
+      throw new RangeError("Maximum output tokens must be a positive safe integer");
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.baseURL = (options.baseURL ?? dialect.defaultBaseURL).replace(/\/+$/, "");
+    this.maxOutputTokens = options.maxOutputTokens;
+    this.reasoningEffort = options.reasoningEffort;
+    this.fetchImplementation = options.fetch ?? globalThis.fetch;
+  }
+  async *stream(request, options) {
+    if (this.dialect.supportsResponseFormat)
+      assertModelResponseFormat(request);
+    else if (request.responseFormat !== void 0)
+      throw new TypeError(`${this.dialect.provider} adapter does not support responseFormat`);
+    yield* executeRecordedRequest2({
+      version: 1,
+      adapter: this.dialect.adapter,
+      purpose: "generation",
+      endpoint: requestEndpoint2(`${this.baseURL}/chat/completions`),
+      request,
+      body: this.createRequest(request)
+    }, options.recordRequest, options.signal, (body) => this.execute(body, request, options));
+  }
+  async *execute(body, request, options) {
+    const response = await this.fetchImplementation(`${this.baseURL}/chat/completions`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${this.apiKey}`, "content-type": "application/json" },
+      body,
+      signal: options.signal
+    });
+    if (!response.ok)
+      throw await this.createApiError(response);
+    const { provider, errorCodePrefix } = this.dialect;
+    for await (const event of streamOpenAICompatibleResponse(response, {
+      signal: options.signal,
+      providerName: provider,
+      requireDone: this.dialect.requireDone,
+      protocolError: /* @__PURE__ */ __name((message, errorOptions) => new OpenAICompatibleProtocolError(provider, errorCodePrefix, message, errorOptions), "protocolError"),
+      finishReasonError: /* @__PURE__ */ __name((finishReason) => new OpenAICompatibleFinishReasonError(provider, errorCodePrefix, finishReason), "finishReasonError")
+    })) {
+      if (event.type === "response.completed" && this.dialect.supportsResponseFormat)
+        validateStructuredModelResponse(event.message, request, event);
+      yield event;
+    }
+  }
+  createRequest(request) {
+    const body = {
+      model: this.model,
+      messages: toOpenAICompatibleMessages(request.messages, { includeToolName: this.dialect.includeToolName }),
+      stream: true
+    };
+    if (this.dialect.streamUsage)
+      body.stream_options = { include_usage: true };
+    if (request.tools.length > 0)
+      body.tools = toOpenAICompatibleTools(request.tools);
+    if (this.maxOutputTokens !== void 0)
+      body[this.dialect.maxTokensField] = this.maxOutputTokens;
+    if (this.reasoningEffort !== void 0)
+      body.reasoning_effort = this.reasoningEffort;
+    if (request.responseFormat !== void 0) {
+      const format = request.responseFormat;
+      body.response_format = format.type === "json" ? { type: "json_object" } : {
+        type: "json_schema",
+        json_schema: omitUndefined3({ name: format.name, schema: format.schema, strict: format.strict })
+      };
+    }
+    this.dialect.extendRequest?.(body, request);
+    return body;
+  }
+  async createApiError(response) {
+    const text = await response.text();
+    let message = text || `${this.dialect.provider} request failed with status ${response.status}`;
+    let providerType;
+    let providerCode;
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (error) {
+      if (!(error instanceof SyntaxError))
+        throw error;
+    }
+    if (typeof parsed?.error?.message === "string")
+      message = parsed.error.message;
+    if (typeof parsed?.error?.type === "string")
+      providerType = parsed.error.type;
+    if (typeof parsed?.error?.code === "string" || typeof parsed?.error?.code === "number")
+      providerCode = parsed.error.code;
+    const retryAfterMs2 = parseRetryAfterMs(response.headers.get("retry-after"));
+    return new OpenAICompatibleApiError(this.dialect.provider, this.dialect.errorCodePrefix, omitUndefined3({
+      status: response.status,
+      message,
+      providerType,
+      providerCode,
+      retryAfterMs: retryAfterMs2
+    }));
+  }
+};
+
+// packages/providers/dist/deepseek/index.js
+var DeepSeekModel = class extends OpenAICompatibleChatModel {
+  static {
+    __name(this, "DeepSeekModel");
+  }
+  constructor(options) {
+    const { thinking, maxTokens, ...shared } = options;
+    super(omitUndefined4({ ...shared, maxOutputTokens: maxTokens }), {
+      provider: "DeepSeek",
+      adapter: "deepseek-chat",
+      errorCodePrefix: "DEEPSEEK",
+      defaultBaseURL: "https://api.deepseek.com",
+      maxTokensField: "max_tokens",
+      streamUsage: true,
+      includeToolName: false,
+      requireDone: false,
+      supportsResponseFormat: false,
+      ...thinking === void 0 ? {} : {
+        extendRequest: /* @__PURE__ */ __name((body) => {
+          body.thinking = { type: thinking };
+        }, "extendRequest")
+      }
+    });
+  }
+};
+
+// packages/providers/dist/kimi/index.js
+import { omitUndefined as omitUndefined5 } from "@sortedyuan/may/core";
+var KimiModel = class extends OpenAICompatibleChatModel {
+  static {
+    __name(this, "KimiModel");
+  }
+  constructor(options) {
+    const { thinking, maxTokens, ...shared } = options;
+    const configured = thinking === void 0 ? void 0 : { ...thinking };
+    super(omitUndefined5({ ...shared, maxOutputTokens: maxTokens }), {
+      provider: "Kimi",
+      adapter: "kimi-chat",
+      errorCodePrefix: "KIMI",
+      defaultBaseURL: "https://api.moonshot.ai/v1",
+      maxTokensField: "max_completion_tokens",
+      streamUsage: true,
+      includeToolName: true,
+      requireDone: true,
+      supportsResponseFormat: false,
+      ...configured === void 0 ? {} : {
+        extendRequest: /* @__PURE__ */ __name((body) => {
+          body.thinking = { ...configured };
+        }, "extendRequest")
+      }
+    });
+  }
+};
+
+// packages/providers/dist/openai/errors.js
+import { omitUndefined as omitUndefined6 } from "@sortedyuan/may/core";
+var OpenAIResponsesError = class extends Error {
+  static {
+    __name(this, "OpenAIResponsesError");
+  }
+  status;
+  providerType;
+  providerCode;
+  requestId;
+  retryAfterMs;
+  constructor(message, options = {}) {
+    super(message, omitUndefined6({ cause: options.cause }));
+    this.name = "OpenAIResponsesError";
+    this.status = options.status;
+    this.providerType = options.providerType;
+    this.providerCode = options.providerCode;
+    this.requestId = options.requestId;
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+var OpenAIResponsesProtocolError = class extends OpenAIResponsesError {
+  static {
+    __name(this, "OpenAIResponsesProtocolError");
+  }
+  constructor(message, options = {}) {
+    super(message, omitUndefined6({ cause: options.cause }));
+    this.name = "OpenAIResponsesProtocolError";
+  }
+};
+
+// packages/providers/dist/openai/openai-responses-model.js
+import { executeRecordedRequest as executeRecordedRequest3, executeRecordedOperation, requestEndpoint as requestEndpoint3 } from "@sortedyuan/may/core";
+import { assertModelResponseFormat as assertModelResponseFormat2, omitUndefined as omitUndefined9, validateStructuredModelResponse as validateStructuredModelResponse2 } from "@sortedyuan/may/core";
+
+// packages/providers/dist/openai/convert.js
+import { UnsupportedContentError as UnsupportedContentError3, omitUndefined as omitUndefined7 } from "@sortedyuan/may/core";
+
+// packages/providers/dist/openai/protocol.js
+var OPENAI_RESPONSES_MODEL_STATE_TYPE = "openai.responses.output.v1";
+
+// packages/providers/dist/openai/convert.js
+function toOpenAIResponsesRequestParts(messages, baseInstructions) {
+  const instructions = [];
+  if (baseInstructions?.trim())
+    instructions.push(baseInstructions);
+  const input = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      const text2 = visibleText(message.content);
+      if (text2 !== "")
+        instructions.push(text2);
+      continue;
+    }
+    if (message.role === "user") {
+      input.push({
+        role: "user",
+        content: toInputContent(message.content, "user")
+      });
+      continue;
+    }
+    if (message.role === "tool") {
+      input.push({
+        type: "function_call_output",
+        call_id: message.toolCallId,
+        output: hasMedia2(message.content) ? toInputContent(message.content, "tool") : visibleText(message.content, "tool")
+      });
+      continue;
+    }
+    const native = nativeItems(message.modelState);
+    if (native !== void 0) {
+      input.push(...native);
+      continue;
+    }
+    const text = visibleText(message.content, "assistant");
+    if (text !== "") {
+      input.push({
+        type: "message",
+        role: "assistant",
+        status: "completed",
+        content: [{ type: "output_text", text, annotations: [] }]
+      });
+    }
+    for (const call of message.toolCalls ?? []) {
+      input.push({
+        type: "function_call",
+        call_id: call.id,
+        name: call.name,
+        arguments: serializeJson3(call.input),
+        status: "completed"
+      });
+    }
+  }
+  return {
+    input,
+    ...instructions.length === 0 ? {} : { instructions: instructions.join("\n\n") }
+  };
+}
+__name(toOpenAIResponsesRequestParts, "toOpenAIResponsesRequestParts");
+function toOpenAIResponsesTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema,
+    strict: false
+  }));
+}
+__name(toOpenAIResponsesTools, "toOpenAIResponsesTools");
+function nativeItems(state) {
+  if (state?.type !== OPENAI_RESPONSES_MODEL_STATE_TYPE)
+    return void 0;
+  if (!isRecord3(state.data) || !Array.isArray(state.data.items)) {
+    throw new OpenAIResponsesProtocolError("OpenAI Responses model state is malformed");
+  }
+  return [...state.data.items];
+}
+__name(nativeItems, "nativeItems");
+function toInputContent(content, role) {
+  return content.flatMap((part) => {
+    if (part.type === "reasoning")
+      return [];
+    if (part.type === "text") {
+      return [{ type: "input_text", text: part.text }];
+    }
+    if (part.type === "json") {
+      return [{ type: "input_text", text: serializeJson3(part.value) }];
+    }
+    if (part.type === "image") {
+      const source = toOpenAIImageSource(part.source);
+      return [
+        omitUndefined7({
+          type: "input_image",
+          ...source,
+          detail: part.detail
+        })
+      ];
+    }
+    if (part.type === "file") {
+      return [{ type: "input_file", ...toOpenAIFileSource(part.source, part.name) }];
+    }
+    throw new UnsupportedContentError3("OpenAI Responses adapter", part.type, role);
+  });
+}
+__name(toInputContent, "toInputContent");
+function visibleText(content, role = "system") {
+  return content.filter((part) => part.type !== "reasoning").map((part) => {
+    if (part.type === "text")
+      return part.text;
+    if (part.type === "json")
+      return serializeJson3(part.value);
+    throw new UnsupportedContentError3("OpenAI Responses adapter", part.type, role);
+  }).join("\n");
+}
+__name(visibleText, "visibleText");
+function hasMedia2(content) {
+  return content.some((part) => part.type === "image" || part.type === "file");
+}
+__name(hasMedia2, "hasMedia");
+function toOpenAIImageSource(source) {
+  if (source.type === "url")
+    return { image_url: source.url };
+  if (source.type === "file")
+    return { file_id: source.fileId };
+  return {
+    image_url: `data:${source.mediaType};base64,${source.data}`
+  };
+}
+__name(toOpenAIImageSource, "toOpenAIImageSource");
+function toOpenAIFileSource(source, name) {
+  if (source.type === "url")
+    return { file_url: source.url };
+  if (source.type === "file")
+    return { file_id: source.fileId };
+  return {
+    filename: name ?? "file",
+    file_data: `data:${source.mediaType};base64,${source.data}`
+  };
+}
+__name(toOpenAIFileSource, "toOpenAIFileSource");
+function serializeJson3(value) {
+  const serialized = JSON.stringify(value);
+  return serialized === void 0 ? "null" : serialized;
+}
+__name(serializeJson3, "serializeJson");
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord3, "isRecord");
+
+// packages/providers/dist/openai/stream.js
+import { omitUndefined as omitUndefined8 } from "@sortedyuan/may/core";
+async function* streamOpenAIResponse(response, signal) {
+  let completed;
+  for await (const data of readSseData(response, signal, (message, options) => new OpenAIResponsesProtocolError(message, options), "OpenAI Responses")) {
+    if (data === "[DONE]")
+      continue;
+    const event = parseJson(data, "stream event");
+    const type = requireString2(event.type, "stream event.type");
+    if (type === "response.output_text.delta") {
+      const delta = requireString2(event.delta, `${type}.delta`);
+      if (delta !== "")
+        yield { type: "text.delta", delta };
+      continue;
+    }
+    if (type === "response.refusal.delta") {
+      const delta = requireString2(event.delta, `${type}.delta`);
+      if (delta !== "")
+        yield { type: "text.delta", delta };
+      continue;
+    }
+    if (type === "response.reasoning_summary_text.delta") {
+      const delta = requireString2(event.delta, `${type}.delta`);
+      if (delta !== "")
+        yield { type: "reasoning.delta", delta };
+      continue;
+    }
+    if (type === "response.completed") {
+      if (completed !== void 0) {
+        throw new OpenAIResponsesProtocolError("OpenAI Responses emitted more than one response.completed event");
+      }
+      completed = event.response;
+      continue;
+    }
+    if (type === "response.failed" || type === "response.incomplete") {
+      throw responseFailure(event.response, type);
+    }
+    if (type === "error")
+      throw streamError(event);
+  }
+  if (completed === void 0) {
+    throw new OpenAIResponsesProtocolError("OpenAI Responses stream ended without response.completed");
+  }
+  const parsed = parseCompletedOpenAIResponse(completed);
+  yield omitUndefined8({ type: "response.completed", message: parsed.message, usage: parsed.usage });
+}
+__name(streamOpenAIResponse, "streamOpenAIResponse");
+function parseCompletedOpenAIResponse(value) {
+  const response = requireRecord2(value, "response.completed.response");
+  const output = requireArray(response.output, "response.output");
+  const content = [];
+  const toolCalls = [];
+  for (const raw of output) {
+    const item = requireRecord2(raw, "response.output item");
+    const type = requireString2(item.type, "response.output item.type");
+    if (type === "image_generation_call" && item.result != null) {
+      const format = item.output_format ?? "png";
+      if (format !== "png" && format !== "jpeg" && format !== "webp")
+        throw new OpenAIResponsesProtocolError("Unsupported generated image format");
+      const data = requireString2(item.result, "image_generation_call.result");
+      if (data === "")
+        throw new OpenAIResponsesProtocolError("Generated image is empty");
+      content.push({ type: "image", source: { type: "base64", mediaType: `image/${format}`, data } });
+      continue;
+    }
+    if (type === "reasoning") {
+      for (const rawSummary of optionalArray(item.summary) ?? []) {
+        const summary = requireRecord2(rawSummary, "reasoning summary");
+        if (summary.type === "summary_text") {
+          const text = requireString2(summary.text, "reasoning summary.text");
+          if (text !== "")
+            content.push({ type: "reasoning", text });
+        }
+      }
+      continue;
+    }
+    if (type === "message") {
+      if (item.role !== "assistant")
+        continue;
+      for (const rawPart of requireArray(item.content, "message.content")) {
+        const part = requireRecord2(rawPart, "message content part");
+        if (part.type === "output_text") {
+          const text = requireString2(part.text, "output_text.text");
+          if (text !== "")
+            content.push({ type: "text", text });
+        }
+        if (part.type === "refusal") {
+          const refusal = requireString2(part.refusal, "refusal.refusal");
+          if (refusal !== "")
+            content.push({ type: "text", text: refusal });
+        }
+      }
+      continue;
+    }
+    if (type === "function_call") {
+      const id = requireString2(item.call_id, "function_call.call_id");
+      const name = requireString2(item.name, "function_call.name");
+      const argumentsJson = requireString2(item.arguments, "function_call.arguments");
+      toolCalls.push({ id, name, input: parseArguments(argumentsJson, id) });
+    }
+  }
+  const message = {
+    role: "assistant",
+    content,
+    ...toolCalls.length === 0 ? {} : { toolCalls },
+    modelState: {
+      type: OPENAI_RESPONSES_MODEL_STATE_TYPE,
+      data: { items: output }
+    }
+  };
+  const usage = parseUsage(response.usage);
+  return omitUndefined8({ message, usage });
+}
+__name(parseCompletedOpenAIResponse, "parseCompletedOpenAIResponse");
+function openAIResponseContent(message) {
+  if (message.content.some((part) => part.type === "image") || message.modelState?.type !== OPENAI_RESPONSES_MODEL_STATE_TYPE)
+    return message.content;
+  const state = requireRecord2(message.modelState.data, "modelState.data");
+  const items = requireArray(state.items, "modelState.data.items");
+  if (!items.some((item) => typeof item === "object" && item !== null && "type" in item && item.type === "image_generation_call"))
+    return message.content;
+  return parseCompletedOpenAIResponse({ output: items }).message.content;
+}
+__name(openAIResponseContent, "openAIResponseContent");
+function parseUsage(value) {
+  if (value === void 0 || value === null)
+    return void 0;
+  const usage = requireRecord2(value, "response.usage");
+  const inputTokens = optionalTokenCount2(usage.input_tokens, "input_tokens");
+  const outputTokens = optionalTokenCount2(usage.output_tokens, "output_tokens");
+  const totalTokens = optionalTokenCount2(usage.total_tokens, "total_tokens");
+  const inputDetails = optionalRecord2(usage.input_tokens_details);
+  const outputDetails = optionalRecord2(usage.output_tokens_details);
+  const cachedReadTokens = optionalTokenCount2(inputDetails?.cached_tokens, "input_tokens_details.cached_tokens");
+  const reasoningTokens = optionalTokenCount2(outputDetails?.reasoning_tokens, "output_tokens_details.reasoning_tokens");
+  if (inputTokens === void 0 && outputTokens === void 0 && totalTokens === void 0 && cachedReadTokens === void 0 && reasoningTokens === void 0) {
+    return void 0;
+  }
+  return omitUndefined8({
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    cachedReadTokens,
+    reasoningTokens,
+    ...cachedReadTokens === void 0 && reasoningTokens === void 0 ? {} : {
+      tokenRelations: {
+        ...cachedReadTokens === void 0 ? {} : { cachedRead: "input" },
+        ...reasoningTokens === void 0 ? {} : { reasoning: "output" }
+      }
+    },
+    ...inputTokens === void 0 || outputTokens === void 0 ? { completeness: { status: "partial", reason: "provider-token-components-missing" } } : {}
+  });
+}
+__name(parseUsage, "parseUsage");
+function parseArguments(value, callId) {
+  try {
+    return JSON.parse(value === "" ? "{}" : value);
+  } catch (error) {
+    throw new OpenAIResponsesProtocolError(`OpenAI Responses function call "${callId}" has invalid arguments JSON`, {
+      cause: error
+    });
+  }
+}
+__name(parseArguments, "parseArguments");
+function responseFailure(value, type) {
+  const response = requireRecord2(value, type);
+  const error = optionalRecord2(response.error);
+  const details = optionalRecord2(response.incomplete_details);
+  const message = typeof error?.message === "string" ? error.message : typeof details?.reason === "string" ? details.reason : `OpenAI Responses emitted ${type}`;
+  return new OpenAIResponsesError(message, {
+    ...typeof error?.code === "string" ? { providerType: error.code } : {}
+  });
+}
+__name(responseFailure, "responseFailure");
+function streamError(event) {
+  const error = optionalRecord2(event.error) ?? event;
+  return new OpenAIResponsesError(typeof error.message === "string" ? error.message : "OpenAI Responses stream error", {
+    ...typeof error.code === "string" ? { providerType: error.code } : typeof error.type === "string" ? { providerType: error.type } : {},
+    ...typeof event.request_id === "string" ? { requestId: event.request_id } : {}
+  });
+}
+__name(streamError, "streamError");
+function parseJson(value, field) {
+  try {
+    return requireRecord2(JSON.parse(value), field);
+  } catch (error) {
+    if (error instanceof OpenAIResponsesProtocolError)
+      throw error;
+    throw new OpenAIResponsesProtocolError(`OpenAI Responses emitted invalid JSON for ${field}`, { cause: error });
+  }
+}
+__name(parseJson, "parseJson");
+function optionalTokenCount2(value, field) {
+  if (value === void 0)
+    return void 0;
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new OpenAIResponsesProtocolError(`response.usage.${field} is invalid`);
+  }
+  return value;
+}
+__name(optionalTokenCount2, "optionalTokenCount");
+function requireRecord2(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new OpenAIResponsesProtocolError(`${field} must be an object`);
+  }
+  return value;
+}
+__name(requireRecord2, "requireRecord");
+function optionalRecord2(value) {
+  return value === void 0 || value === null ? void 0 : requireRecord2(value, "value");
+}
+__name(optionalRecord2, "optionalRecord");
+function requireArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new OpenAIResponsesProtocolError(`${field} must be an array`);
+  }
+  return value;
+}
+__name(requireArray, "requireArray");
+function optionalArray(value) {
+  return value === void 0 ? void 0 : requireArray(value, "value");
+}
+__name(optionalArray, "optionalArray");
+function requireString2(value, field) {
+  if (typeof value !== "string") {
+    throw new OpenAIResponsesProtocolError(`${field} must be a string`);
+  }
+  return value;
+}
+__name(requireString2, "requireString");
+
+// packages/providers/dist/openai/openai-responses-model.js
+var OpenAIResponsesModel = class {
+  static {
+    __name(this, "OpenAIResponsesModel");
+  }
+  supportsRequestRecording = true;
+  contextCompactor;
+  apiKey;
+  model;
+  baseURL;
+  maxOutputTokens;
+  reasoningEffort;
+  reasoningSummary;
+  serverCompactThreshold;
+  store;
+  fetchImplementation;
+  constructor(options) {
+    if (options.apiKey.trim() === "")
+      throw new TypeError("apiKey must not be empty");
+    if (options.model.trim() === "")
+      throw new TypeError("model must not be empty");
+    validateOptionalPositiveInteger(options.maxOutputTokens, "maxOutputTokens");
+    validateOptionalPositiveInteger(options.serverCompactThreshold, "serverCompactThreshold");
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.baseURL = (options.baseURL ?? "https://api.openai.com/v1").replace(/\/+$/u, "");
+    this.maxOutputTokens = options.maxOutputTokens;
+    this.reasoningEffort = options.reasoningEffort;
+    this.reasoningSummary = options.reasoningSummary;
+    this.serverCompactThreshold = options.serverCompactThreshold;
+    this.store = options.store ?? false;
+    this.fetchImplementation = options.fetch ?? globalThis.fetch;
+    this.contextCompactor = {
+      name: "openai-responses-compact",
+      compact: /* @__PURE__ */ __name((snapshot, compactOptions) => this.compact(snapshot, compactOptions.signal, compactOptions.recordRequest), "compact")
+    };
+  }
+  async *stream(request, options) {
+    assertModelResponseFormat2(request);
+    const parts = toOpenAIResponsesRequestParts(request.messages);
+    const body = {
+      model: this.model,
+      input: parts.input,
+      stream: true,
+      store: this.store,
+      include: ["reasoning.encrypted_content"]
+    };
+    if (parts.instructions !== void 0)
+      body.instructions = parts.instructions;
+    if (request.tools.length > 0)
+      body.tools = toOpenAIResponsesTools(request.tools);
+    if (request.responseFormat !== void 0) {
+      const format = request.responseFormat;
+      body.text = {
+        format: format.type === "json" ? { type: "json_object" } : omitUndefined9({ type: "json_schema", name: format.name, schema: format.schema, strict: format.strict })
+      };
+    }
+    if (this.maxOutputTokens !== void 0) {
+      body.max_output_tokens = this.maxOutputTokens;
+    }
+    const reasoning = this.reasoningConfig();
+    if (reasoning !== void 0)
+      body.reasoning = reasoning;
+    if (this.serverCompactThreshold !== void 0) {
+      body.context_management = [
+        {
+          type: "compaction",
+          compact_threshold: this.serverCompactThreshold
+        }
+      ];
+    }
+    yield* executeRecordedRequest3({
+      version: 1,
+      adapter: "openai-responses",
+      purpose: "generation",
+      endpoint: requestEndpoint3(`${this.baseURL}/responses`),
+      request,
+      body
+    }, options.recordRequest, options.signal, (body2) => this.execute(body2, request, options));
+  }
+  async *execute(body, request, options) {
+    const response = await this.fetch("/responses", body, options.signal);
+    for await (const event of streamOpenAIResponse(response, options.signal)) {
+      if (event.type === "response.completed")
+        validateStructuredModelResponse2(event.message, request, event);
+      yield event;
+    }
+  }
+  async compact(snapshot, signal, recorder) {
+    const effectiveSignal = signal ?? new AbortController().signal;
+    const parts = toOpenAIResponsesRequestParts(snapshot.messages, snapshot.instructions);
+    const body = {
+      model: this.model,
+      input: parts.input
+    };
+    if (parts.instructions !== void 0)
+      body.instructions = parts.instructions;
+    const request = {
+      messages: snapshot.instructions === void 0 ? snapshot.messages : [{ role: "system", content: [{ type: "text", text: snapshot.instructions }] }, ...snapshot.messages],
+      tools: []
+    };
+    return executeRecordedOperation({
+      version: 1,
+      adapter: "openai-responses",
+      purpose: "compaction",
+      endpoint: requestEndpoint3(`${this.baseURL}/responses/compact`),
+      request,
+      body
+    }, recorder, effectiveSignal, (serialized) => this.executeCompact(serialized, effectiveSignal));
+  }
+  async executeCompact(body, effectiveSignal) {
+    const response = await this.fetch("/responses/compact", body, effectiveSignal);
+    const value = await response.json().catch((error) => {
+      throw new OpenAIResponsesProtocolError("OpenAI Responses compact returned invalid JSON", { cause: error });
+    });
+    const compacted = requireRecord3(value, "compacted response");
+    if (compacted.object !== "response.compaction") {
+      throw new OpenAIResponsesProtocolError("OpenAI Responses compact returned an unexpected object");
+    }
+    if (!Array.isArray(compacted.output)) {
+      throw new OpenAIResponsesProtocolError("OpenAI Responses compact output must be an array");
+    }
+    if (!compacted.output.some((item) => typeof item === "object" && item !== null && "type" in item && item.type === "compaction")) {
+      throw new OpenAIResponsesProtocolError("OpenAI Responses compact output has no compaction item");
+    }
+    const usage = parseUsage(compacted.usage);
+    const messages = [
+      {
+        role: "assistant",
+        content: [],
+        modelState: {
+          type: OPENAI_RESPONSES_MODEL_STATE_TYPE,
+          data: { items: compacted.output }
+        }
+      }
+    ];
+    return omitUndefined9({
+      messages,
+      // 压缩请求本身就是一次 provider 调用，它的 usage 一并上报给计账方。
+      usage,
+      effectiveTokens: usage?.outputTokens
+    });
+  }
+  reasoningConfig() {
+    if (this.reasoningEffort === void 0 && this.reasoningSummary === void 0) {
+      return void 0;
+    }
+    return omitUndefined9({
+      effort: this.reasoningEffort,
+      generate_summary: this.reasoningSummary
+    });
+  }
+  async fetch(path, body, signal) {
+    const response = await this.fetchImplementation(`${this.baseURL}${path}`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: typeof body === "string" ? body : JSON.stringify(body),
+      signal
+    });
+    if (!response.ok)
+      throw await createApiError2(response);
+    return response;
+  }
+};
+async function createApiError2(response) {
+  const text = await response.text();
+  let message = text || `OpenAI request failed with status ${response.status}`;
+  let providerType;
+  let providerCode;
+  let requestId = response.headers.get("x-request-id") ?? void 0;
+  try {
+    const body = requireRecord3(JSON.parse(text), "error response");
+    const error = requireRecord3(body.error, "error response.error");
+    if (typeof error.message === "string")
+      message = error.message;
+    if (typeof error.type === "string")
+      providerType = error.type;
+    if (typeof error.code === "string")
+      providerCode = error.code;
+    if (typeof body.request_id === "string")
+      requestId = body.request_id;
+  } catch {
+  }
+  const retryAfterMs2 = parseRetryAfterMs(response.headers.get("retry-after"));
+  return new OpenAIResponsesError(message, omitUndefined9({
+    status: response.status,
+    providerType,
+    providerCode,
+    requestId,
+    retryAfterMs: retryAfterMs2
+  }));
+}
+__name(createApiError2, "createApiError");
+function requireRecord3(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new OpenAIResponsesProtocolError(`${field} must be an object`);
+  }
+  return value;
+}
+__name(requireRecord3, "requireRecord");
+function validateOptionalPositiveInteger(value, name) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) {
+    throw new RangeError(`${name} must be a positive safe integer`);
+  }
+}
+__name(validateOptionalPositiveInteger, "validateOptionalPositiveInteger");
+
+// packages/providers/dist/openai-compatible/openai-chat-completions-model.js
+var OpenAIChatCompletionsModel = class extends OpenAICompatibleChatModel {
+  static {
+    __name(this, "OpenAIChatCompletionsModel");
+  }
+  constructor(options) {
+    const { store, ...shared } = options;
+    super(shared, {
+      provider: "OpenAI-compatible chat",
+      adapter: "openai-chat-completions",
+      errorCodePrefix: "OPENAI_CHAT_COMPLETIONS",
+      defaultBaseURL: "https://api.openai.com/v1",
+      maxTokensField: "max_completion_tokens",
+      streamUsage: true,
+      includeToolName: false,
+      requireDone: true,
+      supportsResponseFormat: true,
+      ...store === void 0 ? {} : {
+        extendRequest: /* @__PURE__ */ __name((body) => {
+          body.store = store;
+        }, "extendRequest")
+      }
+    });
+  }
+};
+
+// packages/providers/dist/zhipu/index.js
+import { omitUndefined as omitUndefined10 } from "@sortedyuan/may/core";
+var ZhipuModel = class extends OpenAICompatibleChatModel {
+  static {
+    __name(this, "ZhipuModel");
+  }
+  constructor(options) {
+    const { thinking = "enabled", clearThinking = false, maxTokens, ...shared } = options;
+    super(omitUndefined10({ ...shared, maxOutputTokens: maxTokens }), {
+      provider: "Zhipu",
+      adapter: "zhipu-chat",
+      errorCodePrefix: "ZHIPU",
+      defaultBaseURL: "https://open.bigmodel.cn/api/paas/v4",
+      maxTokensField: "max_tokens",
+      streamUsage: false,
+      includeToolName: false,
+      requireDone: false,
+      supportsResponseFormat: false,
+      extendRequest: /* @__PURE__ */ __name((body, request) => {
+        body.thinking = thinking === "enabled" ? { type: thinking, clear_thinking: clearThinking } : { type: thinking };
+        if (request.tools.length > 0)
+          body.tool_stream = true;
+      }, "extendRequest")
+    });
+  }
+};
+
+// packages/providers/dist/builtins.js
+import { omitUndefined as omitUndefined15 } from "@sortedyuan/may/core";
+
+// packages/providers/dist/gemini/gemini-model.js
+import { randomUUID } from "node:crypto";
+import { executeRecordedRequest as executeRecordedRequest4, omitUndefined as omitUndefined12, requestEndpoint as requestEndpoint4 } from "@sortedyuan/may/core";
+import { assertModelResponseFormat as assertModelResponseFormat3, validateStructuredModelResponse as validateStructuredModelResponse3 } from "@sortedyuan/may/core";
+
+// packages/providers/dist/gemini/convert.js
+import { UnsupportedContentError as UnsupportedContentError4, omitUndefined as omitUndefined11 } from "@sortedyuan/may/core";
+
+// packages/providers/dist/gemini/errors.js
+var GeminiProtocolError = class extends Error {
+  static {
+    __name(this, "GeminiProtocolError");
+  }
+  code = "GEMINI_PROTOCOL_ERROR";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "GeminiProtocolError";
+  }
+};
+var GeminiApiError = class extends Error {
+  static {
+    __name(this, "GeminiApiError");
+  }
+  status;
+  retryAfterMs;
+  code = "GEMINI_API_ERROR";
+  constructor(status, message, retryAfterMs2) {
+    super(message);
+    this.status = status;
+    this.retryAfterMs = retryAfterMs2;
+    this.name = "GeminiApiError";
+  }
+};
+var GeminiFinishReasonError = class extends Error {
+  static {
+    __name(this, "GeminiFinishReasonError");
+  }
+  finishReason;
+  code = "GEMINI_INCOMPLETE_RESPONSE";
+  constructor(finishReason) {
+    super(`Gemini stopped with finish reason "${finishReason}"`);
+    this.finishReason = finishReason;
+    this.name = "GeminiFinishReasonError";
+  }
+};
+
+// packages/providers/dist/gemini/protocol.js
+var GEMINI_MODEL_STATE_TYPE = "google-gemini.content.v1";
+
+// packages/providers/dist/gemini/convert.js
+function toGeminiRequestParts(messages) {
+  const contents = [];
+  const system = [];
+  const nativeCalls = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role === "system") {
+      system.push(...message.content.map((part) => {
+        if (part.type === "text")
+          return { text: part.text };
+        if (part.type === "json")
+          return { text: JSON.stringify(part.value) };
+        throw new UnsupportedContentError4("Google Gemini", part.type, "system");
+      }));
+      continue;
+    }
+    if (message.role === "tool") {
+      const call = nativeCalls.get(message.toolCallId);
+      if (call === void 0 || call.name !== message.name)
+        throw new GeminiProtocolError(`Unmatched Gemini tool result "${message.toolCallId}"`);
+      const response = {
+        [message.isError ? "error" : "output"]: message.content.map((part) => {
+          if (part.type === "text")
+            return part.text;
+          if (part.type === "json")
+            return part.value;
+          throw new UnsupportedContentError4("Google Gemini", part.type, "tool");
+        })
+      };
+      appendContent(contents, "user", [
+        { functionResponse: omitUndefined11({ name: call.name, id: call.id, response }) }
+      ]);
+      continue;
+    }
+    if (message.role === "assistant") {
+      let parts;
+      if (message.modelState?.type === GEMINI_MODEL_STATE_TYPE) {
+        const state = message.modelState.data;
+        if (!isRecord4(state) || !Array.isArray(state.parts) || !Array.isArray(state.toolCallIds))
+          throw new GeminiProtocolError("Malformed Gemini model state");
+        parts = structuredClone(state.parts);
+        let index = 0;
+        for (const part of parts) {
+          if (!isRecord4(part))
+            throw new GeminiProtocolError("Malformed Gemini model state part");
+          if (part.functionCall === void 0)
+            continue;
+          if (!isRecord4(part.functionCall) || typeof part.functionCall.name !== "string" || part.functionCall.args !== void 0 && !isRecord4(part.functionCall.args))
+            throw new GeminiProtocolError("Malformed Gemini model state functionCall");
+          const functionCall = part.functionCall;
+          const callId = state.toolCallIds[index++];
+          const toolCall = message.toolCalls?.find((call) => call.id === callId);
+          if (typeof callId !== "string" || toolCall === void 0 || toolCall.name !== functionCall.name || JSON.stringify(toolCall.input) !== JSON.stringify(functionCall.args ?? {}))
+            throw new GeminiProtocolError("Gemini model state does not match tool calls");
+          nativeCalls.set(callId, functionCall);
+        }
+        if (index !== state.toolCallIds.length || index !== (message.toolCalls?.length ?? 0))
+          throw new GeminiProtocolError("Gemini model state has inconsistent tool calls");
+      } else {
+        parts = message.content.flatMap((part) => part.type === "reasoning" ? [] : [toGeminiPart(part, "assistant")]);
+        for (const call of message.toolCalls ?? []) {
+          if (!isRecord4(call.input))
+            throw new GeminiProtocolError("Gemini tool input must be an object");
+          const functionCall = { id: call.id, name: call.name, args: call.input };
+          parts.push({ functionCall });
+          nativeCalls.set(call.id, functionCall);
+        }
+      }
+      appendContent(contents, "model", parts);
+      continue;
+    }
+    appendContent(contents, "user", message.content.map((part) => toGeminiPart(part, "user")));
+  }
+  return { contents, ...system.length === 0 ? {} : { systemInstruction: { parts: system } } };
+}
+__name(toGeminiRequestParts, "toGeminiRequestParts");
+function appendContent(contents, role, parts) {
+  if (parts.length === 0)
+    return;
+  const previous = contents.at(-1);
+  if (previous?.role === role)
+    previous.parts.push(...parts);
+  else
+    contents.push({ role, parts });
+}
+__name(appendContent, "appendContent");
+function toGeminiPart(part, role) {
+  if (part.type === "text")
+    return { text: part.text };
+  if (part.type === "json")
+    return { text: JSON.stringify(part.value) };
+  if (part.type === "image" || part.type === "audio" || part.type === "file") {
+    if (part.source.type === "base64")
+      return { inlineData: { mimeType: part.source.mediaType, data: part.source.data } };
+    if (part.source.type === "url")
+      return { fileData: { fileUri: part.source.url } };
+  }
+  throw new UnsupportedContentError4("Google Gemini", part.type, role);
+}
+__name(toGeminiPart, "toGeminiPart");
+function convertGeminiUsage(metadata) {
+  const input = tokenCount(metadata.promptTokenCount, "promptTokenCount");
+  const candidates = tokenCount(metadata.candidatesTokenCount, "candidatesTokenCount");
+  const reasoning = tokenCount(metadata.thoughtsTokenCount, "thoughtsTokenCount");
+  const cached = tokenCount(metadata.cachedContentTokenCount, "cachedContentTokenCount");
+  const total = tokenCount(metadata.totalTokenCount, "totalTokenCount");
+  const toolPrompt = tokenCount(metadata.toolUsePromptTokenCount, "toolUsePromptTokenCount");
+  const usage = { tokenRelations: { cachedRead: "input", reasoning: "output" } };
+  if (input !== void 0)
+    usage.inputTokens = input;
+  if (candidates !== void 0 || reasoning !== void 0)
+    usage.outputTokens = tokenCount((candidates ?? 0) + (reasoning ?? 0), "outputTokens");
+  if (reasoning !== void 0)
+    usage.reasoningTokens = reasoning;
+  if (cached !== void 0)
+    usage.cachedReadTokens = cached;
+  if (total !== void 0)
+    usage.totalTokens = total;
+  if (toolPrompt !== void 0 && toolPrompt > 0)
+    usage.items = [
+      { id: "gemini.toolUsePromptTokenCount", quantity: toolPrompt, unit: "token", includedIn: "unknown" }
+    ];
+  if (input !== void 0 && cached !== void 0 && cached > input)
+    throw new GeminiProtocolError("Gemini cachedContentTokenCount exceeds promptTokenCount");
+  if (input === void 0 || usage.outputTokens === void 0 || (toolPrompt ?? 0) > 0)
+    usage.completeness = {
+      status: "partial",
+      reason: "Gemini usage does not completely describe input and output tokens"
+    };
+  return usage;
+}
+__name(convertGeminiUsage, "convertGeminiUsage");
+function tokenCount(value, field) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0))
+    throw new GeminiProtocolError(`${field} must be a non-negative safe integer`);
+  return value;
+}
+__name(tokenCount, "tokenCount");
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord4, "isRecord");
+
+// packages/providers/dist/gemini/gemini-model.js
+var GeminiModel = class {
+  static {
+    __name(this, "GeminiModel");
+  }
+  supportsRequestRecording = true;
+  baseURL;
+  fetchImplementation;
+  options;
+  constructor(options) {
+    if (typeof options.apiKey !== "string" || options.apiKey.trim() === "")
+      throw new TypeError("apiKey must not be empty");
+    if (typeof options.model !== "string" || options.model.trim() === "")
+      throw new TypeError("model must not be empty");
+    if (options.maxOutputTokens !== void 0 && (!Number.isSafeInteger(options.maxOutputTokens) || options.maxOutputTokens < 1))
+      throw new RangeError("maxOutputTokens must be a positive safe integer");
+    if (options.thinkingBudget !== void 0 && (!Number.isSafeInteger(options.thinkingBudget) || options.thinkingBudget < -1))
+      throw new RangeError("thinkingBudget must be an integer greater than or equal to -1");
+    if (options.reasoningEffort !== void 0 && (typeof options.reasoningEffort !== "string" || options.reasoningEffort.trim() === ""))
+      throw new TypeError("reasoningEffort must not be empty");
+    if (options.reasoningEffort !== void 0 && options.thinkingBudget !== void 0)
+      throw new TypeError("reasoningEffort and thinkingBudget are mutually exclusive");
+    if (options.includeThoughts !== void 0 && typeof options.includeThoughts !== "boolean")
+      throw new TypeError("includeThoughts must be a boolean");
+    this.options = { ...options };
+    this.baseURL = (options.baseURL ?? "https://generativelanguage.googleapis.com/v1beta").replace(/\/+$/u, "");
+    const url = new URL(this.baseURL);
+    if (!["https:", "http:"].includes(url.protocol) || url.search || url.hash || url.username || url.password)
+      throw new TypeError("baseURL must be an HTTP URL without credentials, query, or fragment");
+    this.fetchImplementation = options.fetch ?? globalThis.fetch;
+  }
+  async *stream(request, options) {
+    assertModelResponseFormat3(request);
+    const body = toGeminiRequestParts(request.messages);
+    if (body.contents.length === 0)
+      throw new GeminiProtocolError("Gemini requires non-empty contents");
+    if (request.tools.length > 0)
+      body.tools = [
+        {
+          functionDeclarations: request.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parametersJsonSchema: tool.inputSchema
+          }))
+        }
+      ];
+    const config = {};
+    if (this.options.maxOutputTokens !== void 0)
+      config.maxOutputTokens = this.options.maxOutputTokens;
+    if (this.options.reasoningEffort !== void 0 || this.options.thinkingBudget !== void 0 || this.options.includeThoughts !== void 0) {
+      config.thinkingConfig = omitUndefined12({
+        thinkingLevel: this.options.reasoningEffort,
+        thinkingBudget: this.options.thinkingBudget,
+        includeThoughts: this.options.includeThoughts
+      });
+    }
+    if (request.responseFormat !== void 0) {
+      config.responseMimeType = "application/json";
+      if (request.responseFormat.type === "jsonSchema")
+        config.responseJsonSchema = request.responseFormat.schema;
+    }
+    if (Object.keys(config).length > 0)
+      body.generationConfig = config;
+    const model = this.options.model.replace(/^models\//u, "");
+    yield* executeRecordedRequest4({
+      version: 1,
+      adapter: "gemini",
+      purpose: "generation",
+      endpoint: requestEndpoint4(`${this.baseURL}/models/${encodeURIComponent(model)}:streamGenerateContent`),
+      request,
+      body,
+      protocol: { model, alt: "sse" }
+    }, options.recordRequest, options.signal, (body2) => this.execute(body2, model, request, options));
+  }
+  async *execute(body, model, request, options) {
+    const response = await this.fetchImplementation(`${this.baseURL}/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse`, {
+      method: "POST",
+      headers: {
+        "x-goog-api-key": this.options.apiKey,
+        "content-type": "application/json",
+        accept: "text/event-stream"
+      },
+      body,
+      signal: options.signal
+    });
+    if (!response.ok)
+      throw new GeminiApiError(response.status, await response.text(), parseRetryAfterMs(response.headers.get("retry-after")));
+    const message = { role: "assistant", content: [] };
+    const parts = [];
+    const toolCalls = [];
+    let metadata;
+    let finishReason;
+    for await (const data of readSseData(response, options.signal, (message2, cause) => new GeminiProtocolError(message2, cause), "Google Gemini")) {
+      if (data === "[DONE]")
+        break;
+      const chunk = JSON.parse(data);
+      if (!isRecord4(chunk))
+        throw new GeminiProtocolError("Gemini stream chunk must be an object");
+      if (chunk.error !== void 0)
+        throw new GeminiProtocolError(`Gemini stream error: ${describeError(chunk.error)}`);
+      if (isRecord4(chunk.promptFeedback) && chunk.promptFeedback.blockReason !== void 0)
+        throw new GeminiFinishReasonError(String(chunk.promptFeedback.blockReason));
+      if (chunk.usageMetadata !== void 0) {
+        if (!isRecord4(chunk.usageMetadata))
+          throw new GeminiProtocolError("Gemini usageMetadata must be an object");
+        metadata = { ...metadata, ...chunk.usageMetadata };
+        convertGeminiUsage(metadata);
+      }
+      if (chunk.candidates === void 0)
+        continue;
+      if (!Array.isArray(chunk.candidates))
+        throw new GeminiProtocolError("Gemini candidates must be an array");
+      for (const candidate of chunk.candidates) {
+        if (!isRecord4(candidate))
+          throw new GeminiProtocolError("Gemini candidate must be an object");
+        if (candidate.index !== void 0 && candidate.index !== 0)
+          continue;
+        if (candidate.finishReason !== void 0) {
+          if (typeof candidate.finishReason !== "string")
+            throw new GeminiProtocolError("Gemini finishReason must be a string");
+          if (finishReason !== void 0 && finishReason !== candidate.finishReason)
+            throw new GeminiProtocolError("Gemini emitted conflicting finish reasons");
+          finishReason = candidate.finishReason;
+        }
+        if (candidate.content === void 0)
+          continue;
+        if (!isRecord4(candidate.content) || !Array.isArray(candidate.content.parts))
+          throw new GeminiProtocolError("Gemini content.parts must be an array");
+        for (const rawPart of candidate.content.parts) {
+          if (!isRecord4(rawPart))
+            throw new GeminiProtocolError("Gemini part must be an object");
+          if (rawPart.thoughtSignature !== void 0 && typeof rawPart.thoughtSignature !== "string")
+            throw new GeminiProtocolError("Gemini thoughtSignature must be a string");
+          if (rawPart.thought !== void 0 && typeof rawPart.thought !== "boolean")
+            throw new GeminiProtocolError("Gemini thought must be a boolean");
+          const part = rawPart;
+          parts.push(structuredClone(part));
+          if (part.text !== void 0) {
+            if (typeof part.text !== "string")
+              throw new GeminiProtocolError("Gemini text must be a string");
+            const type = part.thought ? "reasoning" : "text";
+            message.content.push({ type, text: part.text });
+            if (part.text !== "")
+              yield { type: part.thought ? "reasoning.delta" : "text.delta", delta: part.text };
+          } else if (part.functionCall !== void 0) {
+            const call = part.functionCall;
+            if (!isRecord4(call) || typeof call.name !== "string" || call.name.trim() === "" || call.args !== void 0 && !isRecord4(call.args) || call.id !== void 0 && (typeof call.id !== "string" || call.id === ""))
+              throw new GeminiProtocolError("Malformed Gemini functionCall");
+            const id = call.id ?? randomUUID();
+            if (toolCalls.some((existing) => existing.id === id))
+              throw new GeminiProtocolError("Gemini emitted duplicate function call IDs");
+            toolCalls.push({ id, name: call.name, input: call.args ?? {} });
+          } else if (part.inlineData !== void 0) {
+            const media = part.inlineData;
+            if (!isRecord4(media) || typeof media.mimeType !== "string" || typeof media.data !== "string")
+              throw new GeminiProtocolError("Malformed Gemini inlineData");
+            const type = media.mimeType.startsWith("image/") ? "image" : media.mimeType.startsWith("audio/") ? "audio" : "file";
+            message.content.push({ type, source: { type: "base64", mediaType: media.mimeType, data: media.data } });
+          } else if (part.thoughtSignature === void 0) {
+            throw new GeminiProtocolError("Unsupported Gemini response part");
+          }
+        }
+      }
+    }
+    options.signal.throwIfAborted();
+    if (finishReason === void 0)
+      throw new GeminiProtocolError("Gemini stream ended without finishReason");
+    if (finishReason !== "STOP")
+      throw new GeminiFinishReasonError(finishReason);
+    if (parts.length === 0)
+      throw new GeminiProtocolError("Gemini completed without content");
+    if (toolCalls.length > 0)
+      message.toolCalls = toolCalls;
+    message.modelState = {
+      type: GEMINI_MODEL_STATE_TYPE,
+      data: { parts, toolCallIds: toolCalls.map((call) => call.id) }
+    };
+    const event = {
+      type: "response.completed",
+      message,
+      ...metadata === void 0 ? {} : { usage: convertGeminiUsage(metadata) }
+    };
+    validateStructuredModelResponse3(message, request, event);
+    yield event;
+  }
+};
+function describeError(error) {
+  if (isRecord4(error) && typeof error.message === "string")
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  return "The server returned an error without a message";
+}
+__name(describeError, "describeError");
+
+// packages/providers/dist/errors.js
+var ProviderAdapterRegistryError = class extends Error {
+  static {
+    __name(this, "ProviderAdapterRegistryError");
+  }
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProviderAdapterRegistryError";
+  }
+};
+var ProviderConfigurationError = class extends ProviderAdapterRegistryError {
+  static {
+    __name(this, "ProviderConfigurationError");
+  }
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ProviderConfigurationError";
+  }
+};
+
+// packages/providers/dist/options.js
+import { omitUndefined as omitUndefined13 } from "@sortedyuan/may/core";
+function providerField(selection, name) {
+  return `providers.${selection.provider}.${name}`;
+}
+__name(providerField, "providerField");
+function tuningOption(selection, name) {
+  return selection.options[name];
+}
+__name(tuningOption, "tuningOption");
+function modelOption(selection, name) {
+  return Object.hasOwn(selection.options, name) ? selection.options[name] : void 0;
+}
+__name(modelOption, "modelOption");
+function optionField(selection, name) {
+  return `models.${selection.profile}.options.${name}`;
+}
+__name(optionField, "optionField");
+function requiredString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new ProviderConfigurationError(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+__name(requiredString, "requiredString");
+function optionalString2(value, field) {
+  if (value === void 0)
+    return void 0;
+  return requiredString(value, field);
+}
+__name(optionalString2, "optionalString");
+function optionalEnum(value, field, allowed) {
+  if (value === void 0)
+    return void 0;
+  if (typeof value !== "string" || !allowed.has(value)) {
+    throw new ProviderConfigurationError(`${field} must be one of: ${[...allowed].join(", ")}`);
+  }
+  return value;
+}
+__name(optionalEnum, "optionalEnum");
+function optionalPositiveInteger(value, field) {
+  if (value === void 0)
+    return void 0;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new ProviderConfigurationError(`${field} must be a positive safe integer`);
+  }
+  return value;
+}
+__name(optionalPositiveInteger, "optionalPositiveInteger");
+function optionalBoolean(value, field) {
+  if (value === void 0)
+    return void 0;
+  if (typeof value !== "boolean") {
+    throw new ProviderConfigurationError(`${field} must be a boolean`);
+  }
+  return value;
+}
+__name(optionalBoolean, "optionalBoolean");
+function requireRecord4(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ProviderConfigurationError(`${field} must be an object`);
+  }
+  return value;
+}
+__name(requireRecord4, "requireRecord");
+function attachModelLimits(model, limits, maxOutputTokens) {
+  const effectiveLimits = mergeLimits(limits, maxOutputTokens);
+  if (effectiveLimits === void 0)
+    return model;
+  return {
+    limits: effectiveLimits,
+    supportsRequestRecording: model.supportsRequestRecording === true,
+    reportsAttempts: model.reportsAttempts,
+    capabilityVersion: model.capabilityVersion,
+    configuration: model.configuration,
+    contextCompactor: model.contextCompactor,
+    ...model.preflight === void 0 ? {} : {
+      preflight: /* @__PURE__ */ __name((request, streamOptions) => model.preflight(request, streamOptions), "preflight")
+    },
+    stream: /* @__PURE__ */ __name((request, streamOptions) => model.stream(request, streamOptions), "stream")
+  };
+}
+__name(attachModelLimits, "attachModelLimits");
+function mergeLimits(limits, maxOutputTokens) {
+  if (limits === void 0 && maxOutputTokens === void 0)
+    return void 0;
+  const effectiveOutputTokens = maxOutputTokens ?? limits?.maxOutputTokens;
+  return omitUndefined13({
+    contextWindowTokens: limits?.contextWindowTokens,
+    maxOutputTokens: effectiveOutputTokens
+  });
+}
+__name(mergeLimits, "mergeLimits");
+
+// packages/providers/dist/capability-validated-model.js
+import { ModelProtocolError, ModelResponseValidationError, assertModelResponseFormat as assertModelResponseFormat5, omitUndefined as omitUndefined14 } from "@sortedyuan/may/core";
+
+// packages/providers/dist/validation.js
+import { assertModelResponseFormat as assertModelResponseFormat4, compileModelSchema, modelSchemaDialect } from "@sortedyuan/may/core";
+import { validateStructuredModelResponse as validateStructuredModelResponse4 } from "@sortedyuan/may/core";
+var ModelRequestValidationError = class extends TypeError {
+  static {
+    __name(this, "ModelRequestValidationError");
+  }
+  result;
+  code = "MODEL_REQUEST_VALIDATION_FAILED";
+  constructor(result) {
+    super(result.issues.map((issue) => `${issue.field}: ${issue.message}`).join("; "));
+    this.result = result;
+    this.name = "ModelRequestValidationError";
+  }
+};
+function validateModelRequest(request, capabilities, options = {}) {
+  assertModelResponseFormat4(request);
+  if (options.unknownPolicy !== void 0 && options.unknownPolicy !== "allow" && options.unknownPolicy !== "require-known")
+    throw new TypeError("unknownPolicy must be allow or require-known");
+  const issues = [];
+  const report = /* @__PURE__ */ __name((field, capability, code, message) => issues.push({ field, capability, code, message }), "report");
+  const values = /* @__PURE__ */ __name((key) => [capabilities.fields?.[key], ...Object.values(capabilities.layers ?? {}).map((layer) => layer[key])].filter((value) => value !== void 0), "values");
+  const requireCapability = /* @__PURE__ */ __name((key, field) => {
+    const candidates = values(key);
+    if (candidates.some((value) => value.status === "unsupported"))
+      report(field, key, "unsupported", `${key} is unsupported`);
+    else if (capabilities.fields?.[key]?.status !== "known")
+      report(field, key, "unknown", `${key} is unknown`);
+  }, "requireCapability");
+  const knownValues = /* @__PURE__ */ __name((key) => values(key).flatMap((value) => value.status === "known" ? [value.value] : []), "knownValues");
+  const limit = /* @__PURE__ */ __name((key, amount, field) => {
+    if (amount > 0 && values(key).some((value) => value.status === "unsupported"))
+      report(field, key, "unsupported", `${key} is unsupported`);
+    const limits = knownValues(key).filter((value) => typeof value === "number");
+    if (limits.length > 0 && amount > Math.min(...limits))
+      report(field, key, "limit", `${key} must not exceed ${Math.min(...limits)}`);
+  }, "limit");
+  let images = 0;
+  let attachments = 0;
+  request.messages.forEach((message, messageIndex) => message.content.forEach((part, partIndex) => {
+    const field = `messages.${messageIndex}.content.${partIndex}`;
+    if (part.type === "reasoning")
+      return;
+    if (part.type === "text" || part.type === "json") {
+      requireCapability("input.text", field);
+      return;
+    }
+    if (part.type === "resource") {
+      requireCapability("input.resource", field);
+      return;
+    }
+    requireCapability(`input.${part.type}`, field);
+    attachments += 1;
+    if (part.type === "image")
+      images += 1;
+    const sourceKey = `input.${part.type}.sources`;
+    requireCapability(sourceKey, `${field}.source`);
+    for (const allowed of knownValues(sourceKey)) {
+      if (Array.isArray(allowed) && !allowed.includes(part.source.type))
+        report(`${field}.source.type`, sourceKey, "unsupported", `${part.source.type} source is unsupported`);
+    }
+    const supplied = options.mediaMetadata?.(part, field);
+    const bytes = part.source.type === "base64" ? Buffer.byteLength(part.source.data, "base64") : supplied?.bytes;
+    const mediaType = part.source.type === "base64" ? part.source.mediaType : supplied?.mediaType;
+    if (bytes !== void 0) {
+      if (!Number.isSafeInteger(bytes) || bytes < 0)
+        throw new TypeError(`${field} media bytes must be a non-negative safe integer`);
+      limit("maxAttachmentBytes", bytes, field);
+    } else if (knownValues("maxAttachmentBytes").length > 0)
+      report(field, "maxAttachmentBytes", "unknown", "Attachment size is unknown");
+    if (part.type === "file") {
+      if (values("fileTypes").some((value) => value.status === "unsupported"))
+        report(field, "fileTypes", "unsupported", "File media types are unsupported");
+      for (const allowed of knownValues("fileTypes")) {
+        if (!Array.isArray(allowed))
+          continue;
+        if (mediaType === void 0)
+          report(field, "fileTypes", "unknown", "File media type is unknown");
+        else if (!allowed.includes(mediaType))
+          report(field, "fileTypes", "unsupported", "File media type is unsupported");
+      }
+    }
+  }));
+  limit("maxImages", images, "messages");
+  limit("maxAttachments", attachments, "messages");
+  if (request.tools.length > 0)
+    requireCapability("tools", "tools");
+  const parameters = options.parameters ?? {};
+  if (Object.keys(parameters).length > 0)
+    requireCapability("parameters", "parameters");
+  const effort = parameters.reasoningEffort;
+  const thinking = parameters.thinking;
+  if (thinking !== void 0 && thinking !== "disabled" && !(typeof thinking === "object" && thinking !== null && "type" in thinking && thinking.type === "disabled")) {
+    const mode = typeof thinking === "object" && thinking !== null && "type" in thinking && thinking.type === "adaptive" ? "adaptive" : typeof thinking === "object" && thinking !== null && "budgetTokens" in thinking ? "budget" : "thinking";
+    requireCapability("reasoning.modes", "parameters.thinking");
+    for (const modes of knownValues("reasoning.modes"))
+      if (Array.isArray(modes) && !modes.includes(mode))
+        report("parameters.thinking", "reasoning.modes", "unsupported", `${mode} reasoning mode is unsupported`);
+  }
+  if (parameters.reasoningSummary !== void 0) {
+    requireCapability("reasoning.modes", "parameters.reasoningSummary");
+    for (const modes of knownValues("reasoning.modes"))
+      if (Array.isArray(modes) && !modes.includes("summary"))
+        report("parameters.reasoningSummary", "reasoning.modes", "unsupported", "reasoning summary mode is unsupported");
+  }
+  if (effort !== void 0) {
+    for (const modes of values("reasoning.modes")) {
+      if (modes.status === "unsupported" || modes.status === "known" && Array.isArray(modes.value) && !modes.value.includes("effort"))
+        report("parameters.reasoningEffort", "reasoning.modes", "unsupported", "effort reasoning mode is unsupported");
+    }
+    const reasoning = capabilities.reasoningEffort;
+    if (reasoning.status === "unsupported")
+      report("parameters.reasoningEffort", "reasoningEffort", "unsupported", "reasoning effort is unsupported");
+    else if (reasoning.status === "unknown")
+      report("parameters.reasoningEffort", "reasoningEffort", "unknown", "reasoning effort is unknown");
+    else if (typeof effort !== "string" || !reasoning.efforts.includes(effort))
+      report("parameters.reasoningEffort", "reasoningEffort", "parameter", `reasoningEffort must be one of ${reasoning.efforts.join(", ")}`);
+  }
+  for (const key of ["maxTokens", "maxOutputTokens"])
+    if (parameters[key] !== void 0) {
+      if (!Number.isSafeInteger(parameters[key]) || parameters[key] < 1)
+        report(`parameters.${key}`, "maxOutputTokens", "parameter", "Output token limit must be a positive safe integer");
+      else
+        limit("maxOutputTokens", parameters[key], `parameters.${key}`);
+    }
+  if (options.estimatedInputTokens !== void 0) {
+    if (!Number.isSafeInteger(options.estimatedInputTokens) || options.estimatedInputTokens < 0)
+      throw new TypeError("estimatedInputTokens must be a non-negative safe integer");
+    const outputTokens = parameters.maxOutputTokens ?? parameters.maxTokens;
+    const reservedOutput = typeof outputTokens === "number" && Number.isSafeInteger(outputTokens) && outputTokens >= 0 ? outputTokens : 0;
+    limit("contextWindowTokens", options.estimatedInputTokens + reservedOutput, "messages");
+    if (knownValues("contextWindowTokens").length > 0 && outputTokens === void 0)
+      report("parameters", "maxOutputTokens", "unknown", "Requested output token reservation is unknown");
+  } else if (knownValues("contextWindowTokens").length > 0) {
+    report("messages", "contextWindowTokens", "unknown", "Input token estimate is unavailable");
+  }
+  for (const schema of knownValues("parameters")) {
+    const validator = compileModelSchema(schema);
+    if (!validator(parameters))
+      report("parameters", "parameters", "parameter", "Parameters do not satisfy the declared constraints");
+  }
+  const format = request.responseFormat;
+  if (format !== void 0) {
+    const key = format.type === "json" ? "structuredOutput.json" : "structuredOutput.jsonSchema";
+    requireCapability(key, "responseFormat");
+    if (format.type === "jsonSchema") {
+      if (typeof format.name !== "string" || !/^[A-Za-z0-9_-]{1,64}$/u.test(format.name))
+        report("responseFormat.name", key, "schema", "Schema name must contain 1 through 64 letters, digits, underscores, or hyphens");
+      const dialect = modelSchemaDialect(format.schema);
+      requireCapability("structuredOutput.schemaDialects", "responseFormat.schema");
+      requireCapability("structuredOutput.schemaConstraint", "responseFormat.schema");
+      for (const allowed of knownValues("structuredOutput.schemaDialects"))
+        if (Array.isArray(allowed) && !allowed.includes(dialect))
+          report("responseFormat.schema", "structuredOutput.schemaDialects", "schema", "Schema dialect is unsupported");
+      for (const constraint of knownValues("structuredOutput.schemaConstraint"))
+        if (!compileModelSchema(constraint)(format.schema))
+          report("responseFormat.schema", "structuredOutput.schemaConstraint", "schema", "Schema exceeds the declared supported scope");
+      compileModelSchema(format.schema);
+    }
+  }
+  const unique = issues.filter((issue, index) => issues.findIndex((other) => other.field === issue.field && other.capability === issue.capability && other.code === issue.code) === index);
+  const invalid = unique.some((issue) => issue.code !== "unknown") || options.unknownPolicy === "require-known" && unique.length > 0;
+  return { status: invalid ? "invalid" : unique.length > 0 ? "unknown" : "valid", issues: unique };
+}
+__name(validateModelRequest, "validateModelRequest");
+
+// packages/providers/dist/capability-validated-model.js
+var CapabilityValidatedModel = class {
+  static {
+    __name(this, "CapabilityValidatedModel");
+  }
+  model;
+  options;
+  contextCompactor;
+  resolver;
+  capabilities;
+  validation;
+  selection;
+  responseFormat;
+  unknownPolicy;
+  constructor(model, selection, options = {}) {
+    this.model = model;
+    this.options = options;
+    this.resolver = options.resolver ?? createModelCapabilityResolver();
+    this.selection = structuredClone(selection);
+    const responseFormat = selection.options.responseFormat;
+    if (responseFormat !== void 0) {
+      if (typeof responseFormat !== "object" || responseFormat === null || !("type" in responseFormat) || responseFormat.type !== "json" && responseFormat.type !== "jsonSchema") {
+        throw new TypeError("options.responseFormat must be a JSON or JSON Schema response format");
+      }
+      this.responseFormat = structuredClone(responseFormat);
+      assertModelResponseFormat5({ messages: [], tools: [], responseFormat: this.responseFormat });
+    }
+    const unknownPolicy = options.unknownPolicy ?? selection.options.unknownCapabilityPolicy ?? "allow";
+    if (unknownPolicy !== "allow" && unknownPolicy !== "require-known")
+      throw new TypeError("unknownCapabilityPolicy must be allow or require-known");
+    this.unknownPolicy = unknownPolicy;
+    const compactor = model.contextCompactor;
+    if (compactor !== void 0)
+      this.contextCompactor = {
+        name: compactor.name,
+        compact: /* @__PURE__ */ __name(async (snapshot, compactOptions) => {
+          compactOptions.signal?.throwIfAborted();
+          const capabilities = await this.getModelCapabilities();
+          compactOptions.signal?.throwIfAborted();
+          const capability = capabilities.fields?.contextCompaction;
+          if (capability?.status === "unsupported" || this.unknownPolicy === "require-known" && capability?.status !== "known") {
+            this.validation = {
+              status: "invalid",
+              issues: [
+                {
+                  field: "contextCompactor",
+                  capability: "contextCompaction",
+                  code: capability?.status === "unsupported" ? "unsupported" : "unknown",
+                  message: "Native Context compaction capability is unavailable"
+                }
+              ]
+            };
+            throw new ModelRequestValidationError(this.validation);
+          }
+          const request = {
+            messages: snapshot.instructions === void 0 ? snapshot.messages : [{ role: "system", content: [{ type: "text", text: snapshot.instructions }] }, ...snapshot.messages],
+            tools: []
+          };
+          this.validate(request, capabilities, { ...this.options, unknownPolicy: this.unknownPolicy });
+          if (capability?.status !== "known")
+            this.validation = {
+              status: "unknown",
+              issues: [
+                ...this.validation.issues,
+                {
+                  field: "contextCompactor",
+                  capability: "contextCompaction",
+                  code: "unknown",
+                  message: "Native Context compaction capability is unknown"
+                }
+              ]
+            };
+          let success = false;
+          try {
+            const result = await compactor.compact(snapshot, compactOptions);
+            success = true;
+            return result;
+          } finally {
+            this.resolver.recordVerification(this.selection, request, success, false, ["contextCompaction"]);
+          }
+        }, "compact")
+      };
+  }
+  get limits() {
+    const limits = {};
+    for (const key of ["contextWindowTokens", "maxOutputTokens"]) {
+      const declarations = [
+        this.model.limits?.[key],
+        this.selection.capabilities?.fields?.[key],
+        this.selection.providerConfig.capabilities?.fields?.[key]
+      ];
+      const resolved = [
+        this.capabilities?.fields?.[key],
+        ...Object.values(this.capabilities?.layers ?? {}).map((layer) => layer[key])
+      ].flatMap((capability) => capability?.status === "known" && typeof capability.value === "number" ? [capability.value] : []);
+      const values = [...declarations, ...resolved].filter((value) => typeof value === "number");
+      if (values.length > 0)
+        limits[key] = Math.min(...values);
+    }
+    return Object.keys(limits).length === 0 ? void 0 : limits;
+  }
+  get reportsAttempts() {
+    return this.model.reportsAttempts;
+  }
+  get supportsRequestRecording() {
+    return this.model.supportsRequestRecording === true;
+  }
+  get capabilityVersion() {
+    return this.capabilities?.version;
+  }
+  get configuration() {
+    const reasoningEffort = this.selection.options.reasoningEffort;
+    return omitUndefined14({
+      provider: this.selection.provider,
+      adapter: this.selection.adapter,
+      model: this.selection.model,
+      profile: this.selection.profile,
+      reasoningEffort: typeof reasoningEffort === "string" ? reasoningEffort : void 0,
+      capabilityVersion: this.capabilityVersion
+    });
+  }
+  get lastValidation() {
+    return this.validation;
+  }
+  async getModelCapabilities() {
+    this.capabilities = await this.resolver.resolve(this.selection);
+    return this.capabilities;
+  }
+  async refreshCapabilities() {
+    this.capabilities = await this.resolver.resolve(this.selection, { refresh: true });
+    return this.capabilities;
+  }
+  async preflight(request, options) {
+    request = this.effectiveRequest(request);
+    options.signal.throwIfAborted();
+    const capabilities = await this.getModelCapabilities();
+    options.signal.throwIfAborted();
+    const { responseFormat: configuredFormat, unknownCapabilityPolicy: configuredPolicy, ...configuredParameters } = this.selection.options;
+    const parameters = configuredParameters;
+    if (parameters.maxTokens === void 0 && parameters.maxOutputTokens === void 0 && this.selection.limits?.maxOutputTokens !== void 0) {
+      const key = ["deepseek-chat", "kimi-chat", "zhipu-chat", "anthropic-messages"].includes(this.selection.adapter) ? "maxTokens" : "maxOutputTokens";
+      parameters[key] = this.selection.limits.maxOutputTokens;
+    }
+    this.validate(request, capabilities, {
+      ...this.options,
+      unknownPolicy: this.unknownPolicy,
+      parameters: this.options.parameters ?? parameters
+    });
+  }
+  async *stream(request, options) {
+    request = this.effectiveRequest(request);
+    await this.preflight(request, options);
+    const capabilities = this.capabilities;
+    let completed = false;
+    let verified = false;
+    let responseValidated = false;
+    try {
+      for await (const event of this.model.stream(request, options)) {
+        if (event.type === "response.completed") {
+          if (completed)
+            throw new ModelProtocolError("Model emitted more than one response.completed event");
+          completed = true;
+          validateStructuredModelResponse4(event.message, request, event);
+          responseValidated = request.responseFormat !== void 0 && (event.message.toolCalls?.length ?? 0) === 0;
+          const limits = [
+            capabilities.fields?.["tools.maxCalls"],
+            ...Object.values(capabilities.layers ?? {}).map((layer) => layer["tools.maxCalls"])
+          ].flatMap((limit) => limit?.status === "known" && typeof limit.value === "number" ? [limit.value] : []);
+          if ((event.message.toolCalls?.length ?? 0) > 0 && capabilities.fields?.["tools.maxCalls"]?.status === "unsupported")
+            throw new ModelResponseValidationError("Model response uses unsupported tools.maxCalls", event);
+          if (limits.length > 0 && (event.message.toolCalls?.length ?? 0) > Math.min(...limits)) {
+            throw new ModelResponseValidationError("Model response exceeds tools.maxCalls", event);
+          }
+        }
+        yield event;
+      }
+      if (!completed)
+        throw new ModelProtocolError("Model stream ended without a response.completed event");
+      verified = true;
+    } finally {
+      this.resolver.recordVerification(this.selection, request, verified, responseValidated);
+    }
+  }
+  validate(request, capabilities, options) {
+    this.validation = validateModelRequest(request, capabilities, options);
+    if (this.validation.status === "invalid")
+      throw new ModelRequestValidationError(this.validation);
+  }
+  effectiveRequest(request) {
+    return request.responseFormat === void 0 && this.responseFormat !== void 0 ? { ...request, responseFormat: this.responseFormat } : request;
+  }
+};
+function createCapabilityValidatedModel(model, selection, options = {}) {
+  return new CapabilityValidatedModel(model, selection, options);
+}
+__name(createCapabilityValidatedModel, "createCapabilityValidatedModel");
+
+// packages/providers/dist/registry.js
+var ProviderAdapterRegistry = class {
+  static {
+    __name(this, "ProviderAdapterRegistry");
+  }
+  validationOptions;
+  factories = /* @__PURE__ */ new Map();
+  constructor(validationOptions = {}) {
+    this.validationOptions = validationOptions;
+  }
+  register(name, factory2) {
+    validateAdapterName(name);
+    if (typeof factory2 !== "object" || factory2 === null) {
+      throw new TypeError("adapter factory must be an object");
+    }
+    if (typeof factory2.create !== "function") {
+      throw new TypeError("adapter factory must define create(selection)");
+    }
+    if (this.factories.has(name)) {
+      throw new ProviderAdapterRegistryError(`Adapter "${name}" is already registered`);
+    }
+    this.factories.set(name, factory2);
+    return this;
+  }
+  has(name) {
+    return this.factories.has(name);
+  }
+  names() {
+    return [...this.factories.keys()];
+  }
+  create(selection) {
+    const factory2 = this.factories.get(selection.adapter);
+    if (factory2 === void 0) {
+      const available = this.names();
+      throw new ProviderAdapterRegistryError(`Unsupported adapter "${selection.adapter}"` + (available.length === 0 ? "; no adapters are registered" : `; available adapters: ${available.join(", ")}`));
+    }
+    const model = factory2.create(selection);
+    return this.validationOptions.validateRequests === true ? createCapabilityValidatedModel(model, selection, this.validationOptions) : model;
+  }
+};
+function validateAdapterName(name) {
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new TypeError("adapter name must be a non-empty string");
+  }
+  if (name !== name.trim()) {
+    throw new TypeError("adapter name must not have surrounding whitespace");
+  }
+}
+__name(validateAdapterName, "validateAdapterName");
+
+// packages/providers/dist/builtins.js
+var OPENAI_REASONING_SUMMARIES = /* @__PURE__ */ new Set(["auto", "concise", "detailed"]);
+var THINKING_TYPES = /* @__PURE__ */ new Set(["enabled", "disabled"]);
+var ANTHROPIC_THINKING_TYPES = /* @__PURE__ */ new Set(["enabled", "adaptive", "disabled"]);
+var THINKING_DISPLAYS = /* @__PURE__ */ new Set(["summarized", "omitted"]);
+var ANTHROPIC_CACHE_TTLS = /* @__PURE__ */ new Set(["5m", "1h"]);
+function createBuiltinProviderAdapterRegistry(options = {}) {
+  const registry = new ProviderAdapterRegistry({
+    ...options,
+    validateRequests: true,
+    resolver: options.resolver ?? createModelCapabilityResolver(omitUndefined15({ fetch: options.fetch }))
+  });
+  const zhipu = factory((selection) => createZhipuModel(selection, options));
+  registry.register("google-gemini", factory((selection) => createGeminiModel(selection, options))).register("deepseek-chat", factory((selection) => createDeepSeekModel(selection, options))).register("zhipu-chat", zhipu).register("kimi-chat", factory((selection) => createKimiModel(selection, options))).register("anthropic-messages", factory((selection) => createAnthropicModel(selection, options))).register("openai-responses", factory((selection) => createOpenAIModel(selection, options))).register("openai-chat-completions", factory((selection) => createOpenAIChatCompletionsModel(selection, options)));
+  return registry;
+}
+__name(createBuiltinProviderAdapterRegistry, "createBuiltinProviderAdapterRegistry");
+function createBuiltinProviderModel(selection, options = {}) {
+  return createBuiltinProviderAdapterRegistry(options).create(selection);
+}
+__name(createBuiltinProviderModel, "createBuiltinProviderModel");
+function createGeminiModel(selection, dependencies) {
+  const maxOutputTokens = optionalPositiveInteger(modelOption(selection, "maxOutputTokens"), optionField(selection, "maxOutputTokens")) ?? selection.limits?.maxOutputTokens;
+  const reasoningEffort = optionalString2(tuningOption(selection, "reasoningEffort"), optionField(selection, "reasoningEffort"));
+  const includeThoughts = optionalBoolean(tuningOption(selection, "includeThoughts"), optionField(selection, "includeThoughts"));
+  const thinkingBudget = tuningOption(selection, "thinkingBudget");
+  if (thinkingBudget !== void 0 && (typeof thinkingBudget !== "number" || !Number.isSafeInteger(thinkingBudget) || thinkingBudget < -1))
+    throw new ProviderConfigurationError(`${optionField(selection, "thinkingBudget")} must be an integer greater than or equal to -1`);
+  const baseURL = providerBaseURL(selection);
+  const options = omitUndefined15({
+    ...credentials(selection),
+    baseURL,
+    maxOutputTokens,
+    reasoningEffort,
+    includeThoughts,
+    thinkingBudget,
+    fetch: dependencies.fetch
+  });
+  return attachModelLimits(new GeminiModel(options), selection.limits, maxOutputTokens);
+}
+__name(createGeminiModel, "createGeminiModel");
+function createDeepSeekModel(selection, dependencies) {
+  const thinking = optionalEnum(tuningOption(selection, "thinking"), optionField(selection, "thinking"), THINKING_TYPES);
+  const reasoningEffort = optionalString2(tuningOption(selection, "reasoningEffort"), optionField(selection, "reasoningEffort"));
+  const maxTokens = optionalPositiveInteger(tuningOption(selection, "maxTokens"), optionField(selection, "maxTokens")) ?? selection.limits?.maxOutputTokens;
+  const baseURL = providerBaseURL(selection);
+  const options = omitUndefined15({
+    ...credentials(selection),
+    baseURL,
+    thinking,
+    reasoningEffort,
+    maxTokens,
+    fetch: dependencies.fetch
+  });
+  return attachModelLimits(new DeepSeekModel(options), selection.limits, maxTokens);
+}
+__name(createDeepSeekModel, "createDeepSeekModel");
+function createZhipuModel(selection, dependencies) {
+  const thinking = optionalEnum(tuningOption(selection, "thinking"), optionField(selection, "thinking"), THINKING_TYPES);
+  const clearThinking = optionalBoolean(tuningOption(selection, "clearThinking"), optionField(selection, "clearThinking"));
+  const reasoningEffort = optionalString2(tuningOption(selection, "reasoningEffort"), optionField(selection, "reasoningEffort"));
+  const maxTokens = optionalPositiveInteger(tuningOption(selection, "maxTokens"), optionField(selection, "maxTokens")) ?? selection.limits?.maxOutputTokens;
+  const baseURL = providerBaseURL(selection);
+  const options = omitUndefined15({
+    ...credentials(selection),
+    baseURL,
+    thinking,
+    clearThinking,
+    reasoningEffort,
+    maxTokens,
+    fetch: dependencies.fetch
+  });
+  return attachModelLimits(new ZhipuModel(options), selection.limits, maxTokens);
+}
+__name(createZhipuModel, "createZhipuModel");
+function createKimiModel(selection, dependencies) {
+  const thinking = optionalKimiThinking(tuningOption(selection, "thinking"), optionField(selection, "thinking"));
+  const reasoningEffort = optionalString2(tuningOption(selection, "reasoningEffort"), optionField(selection, "reasoningEffort"));
+  const maxTokens = optionalPositiveInteger(tuningOption(selection, "maxTokens"), optionField(selection, "maxTokens")) ?? selection.limits?.maxOutputTokens;
+  const baseURL = providerBaseURL(selection);
+  const options = omitUndefined15({
+    ...credentials(selection),
+    baseURL,
+    thinking,
+    reasoningEffort,
+    maxTokens,
+    fetch: dependencies.fetch
+  });
+  return attachModelLimits(new KimiModel(options), selection.limits, maxTokens);
+}
+__name(createKimiModel, "createKimiModel");
+function createAnthropicModel(selection, dependencies) {
+  const thinking = optionalAnthropicThinking(tuningOption(selection, "thinking"), optionField(selection, "thinking"));
+  const reasoningEffort = optionalString2(tuningOption(selection, "reasoningEffort"), optionField(selection, "reasoningEffort"));
+  const maxTokens = optionalPositiveInteger(tuningOption(selection, "maxTokens"), optionField(selection, "maxTokens")) ?? selection.limits?.maxOutputTokens;
+  const baseURL = providerBaseURL(selection);
+  const apiVersion = optionalString2(tuningOption(selection, "apiVersion"), optionField(selection, "apiVersion"));
+  const caching = Object.hasOwn(selection.options, "promptCaching") ? tuningOption(selection, "promptCaching") : selection.providerConfig.options?.promptCaching;
+  const cachingRecord = caching === void 0 || caching === false ? void 0 : requireRecord4(caching, optionField(selection, "promptCaching"));
+  const promptCaching = caching === false ? false : cachingRecord === void 0 ? void 0 : omitUndefined15({
+    ttl: optionalEnum(cachingRecord.ttl, `${optionField(selection, "promptCaching")}.ttl`, ANTHROPIC_CACHE_TTLS),
+    cacheInstructions: optionalBoolean(cachingRecord.cacheInstructions, `${optionField(selection, "promptCaching")}.cacheInstructions`)
+  });
+  const options = omitUndefined15({
+    ...credentials(selection),
+    baseURL,
+    apiVersion,
+    promptCaching,
+    thinking,
+    reasoningEffort,
+    maxTokens,
+    fetch: dependencies.fetch
+  });
+  return attachModelLimits(new AnthropicModel(options), selection.limits, maxTokens);
+}
+__name(createAnthropicModel, "createAnthropicModel");
+function createOpenAIModel(selection, dependencies) {
+  const maxOutputTokens = optionalPositiveInteger(modelOption(selection, "maxOutputTokens"), optionField(selection, "maxOutputTokens")) ?? selection.limits?.maxOutputTokens;
+  const reasoningEffort = optionalString2(tuningOption(selection, "reasoningEffort"), optionField(selection, "reasoningEffort"));
+  const reasoningSummary = optionalEnum(tuningOption(selection, "reasoningSummary"), optionField(selection, "reasoningSummary"), OPENAI_REASONING_SUMMARIES);
+  const serverCompactThreshold = optionalPositiveInteger(tuningOption(selection, "serverCompactThreshold"), optionField(selection, "serverCompactThreshold"));
+  const store = optionalBoolean(tuningOption(selection, "store"), optionField(selection, "store"));
+  const baseURL = providerBaseURL(selection);
+  const options = omitUndefined15({
+    ...credentials(selection),
+    baseURL,
+    maxOutputTokens,
+    reasoningEffort,
+    reasoningSummary,
+    serverCompactThreshold,
+    store,
+    fetch: dependencies.fetch
+  });
+  return attachModelLimits(new OpenAIResponsesModel(options), selection.limits, maxOutputTokens);
+}
+__name(createOpenAIModel, "createOpenAIModel");
+function createOpenAIChatCompletionsModel(selection, dependencies) {
+  const maxOutputTokens = optionalPositiveInteger(modelOption(selection, "maxOutputTokens"), optionField(selection, "maxOutputTokens")) ?? selection.limits?.maxOutputTokens;
+  const reasoningEffort = optionalString2(tuningOption(selection, "reasoningEffort"), optionField(selection, "reasoningEffort"));
+  const store = optionalBoolean(tuningOption(selection, "store"), optionField(selection, "store"));
+  const baseURL = providerBaseURL(selection);
+  const options = omitUndefined15({
+    ...credentials(selection),
+    baseURL,
+    maxOutputTokens,
+    reasoningEffort,
+    store,
+    fetch: dependencies.fetch
+  });
+  return attachModelLimits(new OpenAIChatCompletionsModel(options), selection.limits, maxOutputTokens);
+}
+__name(createOpenAIChatCompletionsModel, "createOpenAIChatCompletionsModel");
+function credentials(selection) {
+  return {
+    apiKey: requiredString(selection.providerConfig.apiKey, providerField(selection, "apiKey")),
+    model: requiredString(selection.model, "model")
+  };
+}
+__name(credentials, "credentials");
+function providerBaseURL(selection) {
+  return optionalString2(selection.providerConfig.baseURL, providerField(selection, "baseURL"));
+}
+__name(providerBaseURL, "providerBaseURL");
+function optionalKimiThinking(value, field) {
+  if (value === void 0)
+    return void 0;
+  const record = requireRecord4(value, field);
+  const type = optionalEnum(record.type, `${field}.type`, THINKING_TYPES);
+  if (type === void 0) {
+    throw new ProviderConfigurationError(`${field}.type is required`);
+  }
+  const keep = record.keep;
+  if (keep === void 0)
+    return { type };
+  if (keep !== "all" && keep !== null) {
+    throw new ProviderConfigurationError(`${field}.keep must be "all" or null`);
+  }
+  return { type, keep };
+}
+__name(optionalKimiThinking, "optionalKimiThinking");
+function optionalAnthropicThinking(value, field) {
+  if (value === void 0)
+    return void 0;
+  const record = requireRecord4(value, field);
+  const type = optionalEnum(record.type, `${field}.type`, ANTHROPIC_THINKING_TYPES);
+  if (type === void 0) {
+    throw new ProviderConfigurationError(`${field}.type is required`);
+  }
+  const display = optionalEnum(record.display, `${field}.display`, THINKING_DISPLAYS);
+  if (type === "enabled") {
+    const budgetTokens = optionalPositiveInteger(record.budgetTokens, `${field}.budgetTokens`);
+    if (budgetTokens === void 0) {
+      throw new ProviderConfigurationError(`${field}.budgetTokens is required when thinking is enabled`);
+    }
+    return omitUndefined15({ type, budgetTokens, display });
+  }
+  return omitUndefined15({ type, display: type === "disabled" ? void 0 : display });
+}
+__name(optionalAnthropicThinking, "optionalAnthropicThinking");
+function factory(create) {
+  return { create };
+}
+__name(factory, "factory");
+
+// packages/providers/dist/retrying-model.js
+import { serializeError, traceError, ModelProtocolError as ModelProtocolError2, ModelResponseValidationError as ModelResponseValidationError2, omitUndefined as omitUndefined16 } from "@sortedyuan/may/core";
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 409, 429]);
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "ECONNABORTED",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETDOWN",
+  "ENETRESET",
+  "ENETUNREACH",
+  "EPIPE",
+  "ETIMEDOUT",
+  "EAI_AGAIN",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_SOCKET"
+]);
+var RETRYABLE_PROVIDER_TYPES = /* @__PURE__ */ new Set([
+  "api_error",
+  "internal_error",
+  "overloaded_error",
+  "rate_limit_error",
+  "server_error"
+]);
+var RetryingModel = class {
+  static {
+    __name(this, "RetryingModel");
+  }
+  model;
+  get supportsRequestRecording() {
+    return this.model.supportsRequestRecording === true;
+  }
+  reportsAttempts = true;
+  get capabilityVersion() {
+    return this.model.capabilityVersion;
+  }
+  get configuration() {
+    return this.model.configuration ?? {};
+  }
+  get limits() {
+    return this.model.limits;
+  }
+  contextCompactor;
+  maxAttempts;
+  baseDelayMs;
+  maxDelayMs;
+  jitterRatio;
+  shouldRetry;
+  sleep;
+  random;
+  constructor(model, options = {}) {
+    this.model = model;
+    if (model.contextCompactor !== void 0) {
+      this.contextCompactor = model.contextCompactor;
+    }
+    this.maxAttempts = positiveInteger(options.maxAttempts ?? 3, "maxAttempts");
+    this.baseDelayMs = nonNegativeNumber(options.baseDelayMs ?? 500, "baseDelayMs");
+    this.maxDelayMs = nonNegativeNumber(options.maxDelayMs ?? 8e3, "maxDelayMs");
+    if (this.baseDelayMs > this.maxDelayMs) {
+      throw new RangeError("baseDelayMs cannot exceed maxDelayMs");
+    }
+    this.jitterRatio = ratio(options.jitterRatio ?? 0.2, "jitterRatio");
+    this.shouldRetry = options.shouldRetry ?? defaultShouldRetryModelError;
+    this.sleep = options.sleep ?? abortableSleep;
+    this.random = options.random ?? Math.random;
+  }
+  async preflight(request, options) {
+    await this.model.preflight?.(request, options);
+  }
+  async *stream(request, options) {
+    await this.preflight(request, options);
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+      let completed = false;
+      let emittedContent = false;
+      let usage;
+      const telemetry = options.attemptObserver?.start(attempt);
+      try {
+        for await (const event of this.model.stream(request, {
+          ...options,
+          ...telemetry?.traceContext === void 0 ? {} : { traceContext: telemetry.traceContext }
+        })) {
+          if (options.signal.aborted)
+            throw abortReason(options.signal);
+          if ((event.type === "text.delta" || event.type === "reasoning.delta") && event.delta.length > 0) {
+            emittedContent = true;
+            telemetry?.content(event.type === "text.delta" ? "text" : "reasoning");
+          }
+          if (event.type === "response.completed") {
+            if (completed)
+              throw new ModelProtocolError2("Model emitted more than one response.completed event");
+            completed = true;
+            usage = event.usage;
+            if (event.message.content.some((part) => part.type === "text" && part.text.length > 0))
+              telemetry?.content("text");
+            if ((event.message.toolCalls?.length ?? 0) > 0)
+              telemetry?.content("tool");
+            if (event.message.content.some((part) => part.type !== "text"))
+              telemetry?.content("other");
+          }
+          yield event;
+        }
+        if (!completed)
+          throw new ModelProtocolError2("Model stream ended without a response.completed event");
+        telemetry?.end(omitUndefined16({ status: "ok", completed, usage }));
+        return;
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "RUN_CHECKPOINT_FAILED")
+          throw error;
+        if (error instanceof ModelResponseValidationError2) {
+          completed = error.responseCompleted;
+          usage = error.usage;
+        }
+        telemetry?.end(omitUndefined16({
+          status: options.signal.aborted ? "cancelled" : "error",
+          error: traceError(error),
+          completed,
+          usage
+        }));
+        const context = {
+          attempt,
+          maxAttempts: this.maxAttempts,
+          signal: options.signal
+        };
+        if (options.signal.aborted || completed || emittedContent || attempt >= this.maxAttempts || !this.shouldRetry(error, context)) {
+          throw error;
+        }
+        const delayMs = this.retryDelay(error, attempt);
+        yield {
+          type: "retrying",
+          attempt: attempt + 1,
+          maxAttempts: this.maxAttempts,
+          delayMs,
+          error: serializeError(error)
+        };
+        const waitStarted = performance.now();
+        try {
+          await this.sleep(delayMs, options.signal);
+        } finally {
+          options.attemptObserver?.retryWait?.(performance.now() - waitStarted);
+        }
+      } finally {
+        telemetry?.end(omitUndefined16({ status: options.signal.aborted ? "cancelled" : "error", completed, usage }));
+      }
+    }
+  }
+  retryDelay(error, failedAttempt) {
+    const requested = retryAfterMs(error);
+    if (requested !== void 0) {
+      if (requested > this.maxDelayMs)
+        throw error;
+      return requested;
+    }
+    const exponential = Math.min(this.baseDelayMs * 2 ** (failedAttempt - 1), this.maxDelayMs);
+    if (exponential === 0 || this.jitterRatio === 0)
+      return exponential;
+    const random = this.random();
+    if (!Number.isFinite(random) || random < 0 || random > 1) {
+      throw new RangeError("random must return a number from 0 through 1");
+    }
+    const factor = 1 - this.jitterRatio + random * this.jitterRatio * 2;
+    return Math.round(Math.min(exponential * factor, this.maxDelayMs));
+  }
+};
+function withModelRetry(model, options = {}) {
+  return new RetryingModel(model, options);
+}
+__name(withModelRetry, "withModelRetry");
+function defaultShouldRetryModelError(error) {
+  return classifyRetryable(error, /* @__PURE__ */ new Set());
+}
+__name(defaultShouldRetryModelError, "defaultShouldRetryModelError");
+function classifyRetryable(error, seen) {
+  if (typeof error !== "object" || error === null || seen.has(error))
+    return false;
+  seen.add(error);
+  const candidate = error;
+  if (candidate.name === "AbortError" || candidate.name === "RunCancelledError") {
+    return false;
+  }
+  const status = candidate.status;
+  if (typeof status === "number") {
+    return RETRYABLE_STATUSES.has(status) || status >= 500;
+  }
+  for (const value of [candidate.code, candidate.errno]) {
+    if (typeof value === "string" && RETRYABLE_CODES.has(value.toUpperCase())) {
+      return true;
+    }
+  }
+  if (typeof candidate.providerType === "string" && RETRYABLE_PROVIDER_TYPES.has(candidate.providerType.toLowerCase())) {
+    return true;
+  }
+  if (candidate.name === "TimeoutError")
+    return true;
+  if (candidate.name === "TypeError" && typeof candidate.message === "string" && /fetch|network|socket|timed?\s*out/i.test(candidate.message)) {
+    return true;
+  }
+  return classifyRetryable(candidate.cause, seen);
+}
+__name(classifyRetryable, "classifyRetryable");
+function retryAfterMs(error) {
+  if (typeof error !== "object" || error === null)
+    return void 0;
+  const value = error.retryAfterMs;
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+__name(retryAfterMs, "retryAfterMs");
+function abortableSleep(delayMs, signal) {
+  if (signal.aborted)
+    return Promise.reject(abortReason(signal));
+  if (delayMs === 0)
+    return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = /* @__PURE__ */ __name(() => {
+      clearTimeout(timer);
+      reject(abortReason(signal));
+    }, "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+__name(abortableSleep, "abortableSleep");
+function abortReason(signal) {
+  if (signal.reason instanceof Error)
+    return signal.reason;
+  return new DOMException(typeof signal.reason === "string" ? signal.reason : "The operation was aborted", "AbortError");
+}
+__name(abortReason, "abortReason");
+function positiveInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new RangeError(`${field} must be a positive safe integer`);
+  }
+  return value;
+}
+__name(positiveInteger, "positiveInteger");
+function nonNegativeNumber(value, field) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new RangeError(`${field} must be a non-negative finite number`);
+  }
+  return value;
+}
+__name(nonNegativeNumber, "nonNegativeNumber");
+function ratio(value, field) {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new RangeError(`${field} must be a number from 0 through 1`);
+  }
+  return value;
+}
+__name(ratio, "ratio");
+
+// packages/providers/dist/selection.js
+import { resolveModelProfile } from "@sortedyuan/may/config";
+import { omitUndefined as omitUndefined17 } from "@sortedyuan/may/core";
+function selectProviderModel(config, selector = {}, resolveOptions = {}) {
+  const profileName = selector.model ?? config.defaultModel ?? onlyModel(config);
+  const profile = resolveModelProfile(config, profileName, resolveOptions);
+  return omitUndefined17({
+    profile: profile.name,
+    provider: profile.provider,
+    adapter: profile.adapter,
+    model: profile.model,
+    providerConfig: profile.providerConfig,
+    options: profile.options,
+    capabilities: profile.capabilities,
+    limits: modelLimits(profile.contextWindowTokens, profile.maxOutputTokens)
+  });
+}
+__name(selectProviderModel, "selectProviderModel");
+function modelLimits(contextWindowTokens, maxOutputTokens) {
+  if (contextWindowTokens === void 0 && maxOutputTokens === void 0)
+    return void 0;
+  return omitUndefined17({ contextWindowTokens, maxOutputTokens });
+}
+__name(modelLimits, "modelLimits");
+function onlyModel(config) {
+  const models = Object.keys(config.models);
+  if (models.length === 0) {
+    throw new ProviderConfigurationError(`No model profiles are configured in ${config.path}`);
+  }
+  if (models.length > 1) {
+    throw new ProviderConfigurationError("Select a model with --model or configure defaultModel");
+  }
+  return models[0];
+}
+__name(onlyModel, "onlyModel");
+
+export {
+  openAIResponseContent,
+  ProviderAdapterRegistryError,
+  ProviderConfigurationError,
+  createModelCapabilityResolver,
+  createBuiltinProviderAdapterRegistry,
+  createBuiltinProviderModel,
+  withModelRetry,
+  selectProviderModel
+};
+//# sourceMappingURL=chunk-WVIRS76R.js.map