@archships/dim-agent-sdk 0.0.3 → 0.0.4

package/dist/src/providers/aihubmix-responses/index.js

@@ -0,0 +1,759 @@
+// src/providers/core/create-provider-factory.ts
+function createProviderFactory(definition) {
+  return function createConfiguredAdapter(options) {
+    const provider = options.provider ?? definition.defaultProvider;
+    const defaultModel = {
+      provider,
+      modelId: options.defaultModel
+    };
+    return {
+      provider,
+      defaultModel,
+      async* stream(request) {
+        const requestId = request.requestId ?? crypto.randomUUID();
+        const model = request.model ?? defaultModel;
+        yield { type: "response_start", requestId, model };
+        const context = {
+          options,
+          provider,
+          defaultModel,
+          request: {
+            ...request,
+            model
+          }
+        };
+        let result;
+        try {
+          result = await definition.driver.generate(context);
+        } catch (error) {
+          const payload = definition.driver.normalizeError ? await definition.driver.normalizeError(error, context) : createFallbackErrorPayload(provider, error);
+          yield {
+            type: "error",
+            requestId,
+            error: payload,
+            terminal: true
+          };
+          return;
+        }
+        for (const segment of result.content) {
+          if (segment.type === "text") {
+            if (segment.text.length > 0)
+              yield { type: "text_delta", requestId, delta: segment.text };
+            continue;
+          }
+          if (segment.type === "thinking") {
+            if (segment.text.length > 0)
+              yield { type: "thinking_delta", requestId, delta: segment.text };
+            continue;
+          }
+          yield {
+            type: "tool_call_start",
+            requestId,
+            callId: segment.callId,
+            toolName: segment.toolName
+          };
+          yield {
+            type: "tool_call_args_delta",
+            requestId,
+            callId: segment.callId,
+            delta: segment.argsText
+          };
+          yield {
+            type: "tool_call_end",
+            requestId,
+            callId: segment.callId
+          };
+        }
+        yield {
+          type: "response_end",
+          requestId,
+          stopReason: result.stopReason,
+          usage: result.usage,
+          assistantMetadata: result.assistantMetadata
+        };
+      }
+    };
+  };
+}
+function createFallbackErrorPayload(provider, error) {
+  if (error instanceof Error) {
+    return {
+      code: `${provider}_request_error`,
+      message: error.message
+    };
+  }
+  return {
+    code: `${provider}_request_error`,
+    message: String(error)
+  };
+}
+
+// src/providers/aihubmix-responses/driver.ts
+import { APICallError } from "@ai-sdk/provider";
+import { createAihubmix } from "@aihubmix/ai-sdk-provider";
+
+// src/utils/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+// src/providers/shared/usage.ts
+function normalizeLanguageModelUsage(raw) {
+  if (!raw)
+    return;
+  const promptTokens = raw.inputTokens.total ?? 0;
+  const completionTokens = raw.outputTokens.total ?? 0;
+  const totalTokens = promptTokens + completionTokens;
+  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0)
+    return;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens
+  };
+}
+function mapLanguageModelFinishReason(reason) {
+  const raw = reason.raw?.toLowerCase();
+  if (raw === "cancelled" || raw === "canceled")
+    return "cancelled";
+  switch (reason.unified) {
+    case "tool-calls":
+      return "tool_call";
+    case "length":
+      return "length";
+    case "content-filter":
+    case "error":
+      return "error";
+    case "other":
+      return raw === "cancelled" || raw === "canceled" ? "cancelled" : "final";
+    case "stop":
+    default:
+      return "final";
+  }
+}
+
+// src/providers/shared/ai-sdk-driver.ts
+async function generateWithAiSdk(input) {
+  const result = await input.model.doGenerate(input.callOptions);
+  const content = [];
+  for (const part of result.content) {
+    if (part.type === "text") {
+      if (part.text.length > 0)
+        content.push({ type: "text", text: part.text });
+      continue;
+    }
+    if (part.type === "reasoning") {
+      if (part.text.length > 0)
+        content.push({ type: "thinking", text: part.text });
+      continue;
+    }
+    if (part.type === "tool-call") {
+      content.push({
+        type: "tool_call",
+        callId: part.toolCallId,
+        toolName: part.toolName,
+        argsText: part.input
+      });
+    }
+  }
+  return {
+    content,
+    stopReason: mapLanguageModelFinishReason(result.finishReason),
+    usage: normalizeLanguageModelUsage(result.usage),
+    assistantMetadata: input.createAssistantMetadata?.(result)
+  };
+}
+
+// src/providers/shared/auth-warning.ts
+var warnedProviders = new Set;
+function warnIfPlaceholderApiKey(input) {
+  if (!input.shouldWarn)
+    return;
+  if (false)
+    ;
+  if (warnedProviders.has(input.provider))
+    return;
+  warnedProviders.add(input.provider);
+  const suffix = input.hint ? ` ${input.hint}` : "";
+  console.warn(`[dim-agent-sdk] ${input.provider} is using a placeholder API key because no apiKey or provider-native auth configuration was provided. ` + `If you rely on external authentication, ensure your custom fetch or provider-native headers add real credentials before the request is sent upstream.${suffix}`);
+}
+
+// src/providers/shared/fetch.ts
+function createProviderFetch(input) {
+  const fetchImpl = input.fetch ?? globalThis.fetch;
+  if (!input.stripWhen || !input.stripHeaders || input.stripHeaders.length === 0)
+    return fetchImpl;
+  const headersToStrip = new Set(input.stripHeaders.map((header) => header.toLowerCase()));
+  const wrappedFetch = Object.assign((resource, init) => {
+    if (typeof resource === "string" || resource instanceof URL) {
+      const headers = new Headers(init?.headers);
+      for (const header of headersToStrip)
+        headers.delete(header);
+      return fetchImpl(resource, { ...init, headers });
+    }
+    const request = new Request(resource, init);
+    for (const header of headersToStrip)
+      request.headers.delete(header);
+    return fetchImpl(request);
+  }, {
+    preconnect: typeof fetchImpl.preconnect === "function" ? fetchImpl.preconnect.bind(fetchImpl) : (_url, _options) => {}
+  });
+  return wrappedFetch;
+}
+function hasHeader(headers, target) {
+  if (!headers)
+    return false;
+  const normalized = target.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === normalized);
+}
+
+// src/providers/shared/http-error.ts
+import { STATUS_CODES } from "node:http";
+var MAX_TEXT_CHARS = 4000;
+var MAX_JSON_DEPTH = 4;
+var MAX_JSON_ARRAY_ITEMS = 20;
+var MAX_JSON_OBJECT_KEYS = 40;
+var TRUNCATED_SUFFIX = "...[truncated]";
+function createApiCallErrorPayload(input) {
+  const responseBody = input.error.responseBody ? parseErrorBody(input.error.responseBody) : limitJsonValue(input.error.data);
+  return {
+    code: input.code,
+    message: `${input.provider} request failed${input.error.statusCode ? ` with status ${input.error.statusCode}` : ""}`,
+    status: input.error.statusCode,
+    retryable: input.error.isRetryable,
+    details: {
+      provider: input.provider,
+      endpoint: input.error.url,
+      ...input.error.statusCode ? { statusText: STATUS_CODES[input.error.statusCode] ?? undefined } : {},
+      ...responseBody === undefined ? {} : { responseBody }
+    }
+  };
+}
+function createRequestErrorPayload(input) {
+  if (input.error instanceof Error) {
+    return {
+      code: input.code,
+      message: input.error.message
+    };
+  }
+  return {
+    code: input.code,
+    message: String(input.error)
+  };
+}
+function parseErrorBody(value) {
+  const normalized = value.trim();
+  if (!normalized)
+    return;
+  try {
+    return limitJsonValue(JSON.parse(normalized));
+  } catch {
+    return truncateText(normalized);
+  }
+}
+function limitJsonValue(value, depth = 0) {
+  if (value === undefined)
+    return;
+  if (value === null || typeof value === "boolean" || typeof value === "number")
+    return value;
+  if (typeof value === "string")
+    return truncateText(value);
+  if (Array.isArray(value))
+    return value.slice(0, MAX_JSON_ARRAY_ITEMS).map((item) => limitJsonValue(item, depth + 1));
+  if (typeof value === "object") {
+    if (depth >= MAX_JSON_DEPTH)
+      return truncateText(JSON.stringify(value));
+    const limited = {};
+    for (const [key, child] of Object.entries(value).slice(0, MAX_JSON_OBJECT_KEYS))
+      limited[key] = limitJsonValue(child, depth + 1);
+    return limited;
+  }
+  return truncateText(String(value));
+}
+function truncateText(value) {
+  if (value.length <= MAX_TEXT_CHARS)
+    return value;
+  return `${value.slice(0, MAX_TEXT_CHARS)}${TRUNCATED_SUFFIX}`;
+}
+
+// src/contracts/content-normalize.ts
+function isTextContent(value) {
+  return isRecord(value) && value.type === "text" && typeof value.text === "string" && (value.annotations === undefined || isRecord(value.annotations)) && (value._meta === undefined || isRecord(value._meta));
+}
+function isImageContent(value) {
+  return isRecord(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string" && (value.annotations === undefined || isRecord(value.annotations)) && (value._meta === undefined || isRecord(value._meta));
+}
+function isContentBlock(value) {
+  return isTextContent(value) || isImageContent(value);
+}
+function normalizeContent(input) {
+  if (typeof input === "string") {
+    return [{ type: "text", text: input }];
+  }
+  if (Array.isArray(input)) {
+    const blocks = input.filter((item) => item != null);
+    if (!blocks.every(isContentBlock))
+      throw new TypeError("Content array must contain only text or image blocks");
+    return blocks.map((block) => ({ ...block }));
+  }
+  if (!isContentBlock(input))
+    throw new TypeError("Content must be a string, content block, or content block array");
+  return [{ ...input }];
+}
+function contentToText(content) {
+  return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+
+// src/utils/json.ts
+function isJsonSafeValue(value) {
+  if (value === null)
+    return true;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return true;
+  if (Array.isArray(value))
+    return value.every(isJsonSafeValue);
+  if (isRecord(value))
+    return Object.values(value).every(isJsonSafeValue);
+  return false;
+}
+function assertJsonSafeObject(value, label) {
+  if (!isRecord(value) || !isJsonSafeValue(value))
+    throw new TypeError(`${label} must be a JSON-safe object`);
+}
+function parseJsonObject(value, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${label} must be valid JSON: ${message}`);
+  }
+  if (!isRecord(parsed))
+    throw new Error(`${label} must decode to a JSON object`);
+  return parsed;
+}
+
+// src/providers/shared/prompt.ts
+function mapToolDefinitionsToLanguageModelTools(tools) {
+  if (!tools || tools.length === 0)
+    return;
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  }));
+}
+function messagesToLanguageModelPrompt(messages, options = {}) {
+  const prompt = [];
+  const systemContent = messages.filter((message) => message.role === "system").map((message) => contentToText(message.content)).filter(Boolean).join(`
+
+`);
+  if (systemContent)
+    prompt.push({ role: "system", content: systemContent });
+  for (const message of messages) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "tool") {
+      prompt.push(toolMessageToPrompt(message));
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = [
+        ...options.assistantPrefixParts?.(message) ?? [],
+        ...contentBlocksToPromptParts(message.content),
+        ...toolCallsToPromptParts(message.toolCalls)
+      ];
+      if (content.length > 0)
+        prompt.push({ role: "assistant", content });
+      continue;
+    }
+    prompt.push({
+      role: "user",
+      content: contentBlocksToPromptParts(message.content)
+    });
+  }
+  return prompt;
+}
+function contentBlocksToPromptParts(content) {
+  return content.map((block) => {
+    if (block.type === "text")
+      return { type: "text", text: block.text };
+    return {
+      type: "file",
+      data: block.data,
+      mediaType: block.mimeType
+    };
+  });
+}
+function toolCallsToPromptParts(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0)
+    return [];
+  return toolCalls.map((toolCall) => ({
+    type: "tool-call",
+    toolCallId: toolCall.id,
+    toolName: toolCall.function.name,
+    input: toolCall.function.arguments
+  }));
+}
+function toolMessageToPrompt(message) {
+  return {
+    role: "tool",
+    content: [{
+      type: "tool-result",
+      toolCallId: message.toolCallId,
+      toolName: message.toolName,
+      output: toolMessageToOutput(message)
+    }]
+  };
+}
+function toolMessageToOutput(message) {
+  if (message.structuredContent) {
+    assertJsonSafeObject(message.structuredContent, "Tool structuredContent");
+    return {
+      type: "json",
+      value: message.structuredContent
+    };
+  }
+  const text = contentToText(message.content);
+  if (message.isError === true) {
+    return {
+      type: "json",
+      value: {
+        content: text,
+        isError: true
+      }
+    };
+  }
+  return {
+    type: "text",
+    value: text
+  };
+}
+
+// src/providers/shared/reasoning.ts
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+var LOW_HIGH_REASONING_EFFORT_MAP = {
+  none: "low",
+  minimal: "low",
+  low: "low",
+  medium: "high",
+  high: "high",
+  xhigh: "high"
+};
+var LOW_MEDIUM_HIGH_REASONING_EFFORT_MAP = {
+  none: "low",
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "high"
+};
+function normalizeReasoningConfig(reasoning) {
+  if (!isRecord2(reasoning))
+    return;
+  if (reasoning.enabled === false)
+    return;
+  return reasoning;
+}
+function resolveReasoningBudget(reasoning, fallback = 1024) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  for (const key of ["budgetTokens", "budget_tokens", "thinkingBudget"]) {
+    const value = normalized[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0)
+      return Math.floor(value);
+  }
+  return fallback;
+}
+function resolveReasoningEffort(reasoning, allowedValues) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const rawEffort = normalized.reasoningEffort ?? normalized.effort;
+  if (typeof rawEffort !== "string" || rawEffort.length === 0)
+    return;
+  if (!allowedValues || allowedValues.includes(rawEffort))
+    return rawEffort;
+  return;
+}
+function resolveLowHighReasoningEffort(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const rawEffort = normalized.reasoningEffort ?? normalized.effort;
+  return typeof rawEffort === "string" ? LOW_HIGH_REASONING_EFFORT_MAP[rawEffort] : undefined;
+}
+function resolveLowMediumHighReasoningEffort(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const rawEffort = normalized.reasoningEffort ?? normalized.effort;
+  return typeof rawEffort === "string" ? LOW_MEDIUM_HIGH_REASONING_EFFORT_MAP[rawEffort] : undefined;
+}
+function buildOpenAIResponsesProviderOptions(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const next = {};
+  for (const [key, value] of Object.entries(normalized)) {
+    if (key === "enabled" || key === "budgetTokens" || key === "budget_tokens" || key === "thinkingBudget" || key === "includeThoughts")
+      continue;
+    if (key === "effort") {
+      next.reasoningEffort = value;
+      continue;
+    }
+    if (key === "summary") {
+      next.reasoningSummary = value;
+      continue;
+    }
+    next[key] = value;
+  }
+  if (next.reasoningSummary === undefined)
+    next.reasoningSummary = "auto";
+  return next;
+}
+function buildOpenAIResponsesRequestReasoning(reasoning) {
+  const options = buildOpenAIResponsesProviderOptions(reasoning);
+  if (!options)
+    return;
+  const next = {};
+  if (typeof options.reasoningEffort === "string")
+    next.effort = options.reasoningEffort;
+  if (typeof options.reasoningSummary === "string")
+    next.summary = options.reasoningSummary;
+  return next.effort || next.summary ? next : undefined;
+}
+function buildReasoningEffortProviderOptions(reasoning, allowedValues) {
+  const reasoningEffort = resolveReasoningEffort(reasoning, allowedValues);
+  return reasoningEffort ? { reasoningEffort } : undefined;
+}
+function buildAnthropicThinkingProviderOptions(reasoning) {
+  const budget = resolveReasoningBudget(reasoning);
+  if (!budget)
+    return { thinking: undefined, sendReasoning: undefined };
+  return {
+    thinking: {
+      type: "enabled",
+      budgetTokens: budget
+    },
+    sendReasoning: true
+  };
+}
+function buildGeminiThinkingProviderOptions(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  return {
+    thinkingConfig: {
+      thinkingBudget: resolveReasoningBudget(normalized) ?? 1024,
+      includeThoughts: normalized.includeThoughts !== false
+    }
+  };
+}
+function buildMoonshotThinkingProviderOptions(reasoning) {
+  const budget = resolveReasoningBudget(reasoning);
+  if (!budget)
+    return;
+  return {
+    thinking: {
+      type: "enabled",
+      budgetTokens: budget
+    }
+  };
+}
+function buildDeepSeekThinkingProviderOptions(reasoning) {
+  return normalizeReasoningConfig(reasoning) ? { thinking: { type: "enabled" } } : undefined;
+}
+
+// src/providers/shared/provider-state.ts
+var PROVIDER_STATE_METADATA_KEY = "_dimProviderState";
+function attachProviderState(metadata, provider, state) {
+  if (!state || Object.keys(state).length === 0)
+    return metadata;
+  const nextMetadata = metadata ? structuredClone(metadata) : {};
+  const currentBag = isRecord3(nextMetadata[PROVIDER_STATE_METADATA_KEY]) ? nextMetadata[PROVIDER_STATE_METADATA_KEY] : {};
+  nextMetadata[PROVIDER_STATE_METADATA_KEY] = {
+    ...currentBag,
+    [provider]: structuredClone(state)
+  };
+  return nextMetadata;
+}
+function readProviderState(message, provider) {
+  if (message.role !== "assistant" || !isRecord3(message.metadata))
+    return;
+  const bag = message.metadata[PROVIDER_STATE_METADATA_KEY];
+  if (!isRecord3(bag))
+    return;
+  const state = bag[provider];
+  return isRecord3(state) ? structuredClone(state) : undefined;
+}
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/providers/shared/responses-state.ts
+function sliceMessagesForResponses(messages, stateKey) {
+  let previousResponseId;
+  let startIndex = 0;
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const state = readProviderState(messages[index], stateKey);
+    if (typeof state?.responseId === "string") {
+      previousResponseId = state.responseId;
+      startIndex = index + 1;
+      break;
+    }
+  }
+  return {
+    messages: messages.slice(startIndex),
+    previousResponseId
+  };
+}
+function createResponsesAssistantMetadata(input) {
+  const responseId = resolveResponseId(input.result, input.providerMetadataKey);
+  if (!responseId)
+    return;
+  return attachProviderState(undefined, input.stateKey, { responseId });
+}
+function resolveResponseId(result, providerMetadataKey) {
+  const providerMetadata = providerMetadataKey ? result.providerMetadata?.[providerMetadataKey] : undefined;
+  if (isRecord(providerMetadata) && typeof providerMetadata.responseId === "string")
+    return providerMetadata.responseId;
+  if (typeof result.response?.id === "string")
+    return result.response.id;
+  return extractResponseIdFromBody(result.response?.body);
+}
+function extractResponseIdFromBody(body) {
+  if (isRecord(body) && typeof body.id === "string")
+    return body.id;
+  if (typeof body !== "string")
+    return;
+  try {
+    const parsed = JSON.parse(body);
+    return isRecord(parsed) && typeof parsed.id === "string" ? parsed.id : undefined;
+  } catch {
+    return;
+  }
+}
+
+// src/providers/aihubmix-responses/state.ts
+var AIHUBMIX_RESPONSES_STATE_KEY = "aihubmixResponses";
+function sliceMessagesForAihubmixResponses(messages) {
+  return sliceMessagesForResponses(messages, AIHUBMIX_RESPONSES_STATE_KEY);
+}
+function createAihubmixResponsesAssistantMetadata(result) {
+  return createResponsesAssistantMetadata({
+    result,
+    stateKey: AIHUBMIX_RESPONSES_STATE_KEY,
+    providerMetadataKey: "aihubmix"
+  });
+}
+
+// src/providers/aihubmix-responses/driver.ts
+var PLACEHOLDER_API_KEY = "dim-placeholder-key";
+var aihubmixResponsesDriver = {
+  async generate(context) {
+    const requestReasoning = buildOpenAIResponsesRequestReasoning(context.request.reasoning);
+    const model = createProvider(context.options, requestReasoning).responses(context.request.model.modelId);
+    const { messages, previousResponseId } = sliceMessagesForAihubmixResponses(context.request.messages);
+    const aihubmixProviderOptions = {
+      ...buildOpenAIResponsesProviderOptions(context.request.reasoning) ?? {},
+      ...previousResponseId ? { previousResponseId } : {}
+    };
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...Object.keys(aihubmixProviderOptions).length > 0 ? { providerOptions: { openai: aihubmixProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions,
+      createAssistantMetadata: createAihubmixResponsesAssistantMetadata
+    });
+  },
+  normalizeError(error) {
+    if (APICallError.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "aihubmix_responses_http_error",
+        provider: "AIHubMix Responses",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "aihubmix_responses_request_error",
+      error
+    });
+  }
+};
+function createProvider(options, requestReasoning) {
+  const stripAuthorization = !options.apiKey;
+  warnIfPlaceholderApiKey({
+    provider: "AIHubMix Responses",
+    shouldWarn: stripAuthorization,
+    hint: "This adapter does not expose provider-native auth headers in its options, so external auth must be added inside custom fetch when apiKey is omitted."
+  });
+  return createAihubmix({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY,
+    compatibility: options.compatibility,
+    fetch: createReasoningAwareResponsesFetch({
+      fetch: options.fetch,
+      stripAuthorization,
+      requestReasoning
+    })
+  });
+}
+function createReasoningAwareResponsesFetch(input) {
+  const baseFetch = createProviderFetch({
+    fetch: input.fetch,
+    stripHeaders: ["authorization"],
+    stripWhen: input.stripAuthorization
+  });
+  if (!input.requestReasoning)
+    return baseFetch;
+  const wrappedFetch = Object.assign(async (resource, init) => {
+    if (!init?.body)
+      return baseFetch(resource, init);
+    const body = parseJsonBody(init.body);
+    if (!isRecord(body) || body.reasoning !== undefined)
+      return baseFetch(resource, init);
+    return baseFetch(resource, {
+      ...init,
+      body: JSON.stringify({
+        ...body,
+        reasoning: input.requestReasoning
+      })
+    });
+  }, {
+    preconnect: typeof baseFetch.preconnect === "function" ? baseFetch.preconnect.bind(baseFetch) : undefined
+  });
+  return wrappedFetch;
+}
+function parseJsonBody(body) {
+  if (typeof body !== "string")
+    return;
+  try {
+    return JSON.parse(body);
+  } catch {
+    return;
+  }
+}
+
+// src/providers/aihubmix-responses/adapter.ts
+var createAihubmixResponsesAdapter = createProviderFactory({
+  defaultProvider: "aihubmix-responses",
+  driver: aihubmixResponsesDriver
+});
+export {
+  createAihubmixResponsesAdapter
+};