@robota-sdk/agent-provider 3.0.0-beta.64

package/src/bytedance/status-mapper.test.ts

@@ -0,0 +1,299 @@
+import { describe, expect, it } from 'vitest';
+import {
+  mapVideoStatus,
+  mapInitialStatus,
+  mapVideoJobSnapshot,
+  toIsoTimestamp,
+} from './status-mapper';
+import type { IBytedanceVideoTaskResponse } from './types';
+
+describe('mapVideoStatus', () => {
+  it.each([
+    ['queued', 'queued'],
+    ['pending', 'queued'],
+    ['submitted', 'queued'],
+    ['running', 'running'],
+    ['processing', 'running'],
+    ['in_progress', 'running'],
+    ['succeeded', 'succeeded'],
+    ['success', 'succeeded'],
+    ['completed', 'succeeded'],
+    ['failed', 'failed'],
+    ['error', 'failed'],
+    ['cancelled', 'cancelled'],
+    ['canceled', 'cancelled'],
+  ])('maps "%s" to "%s"', (input, expected) => {
+    const result = mapVideoStatus(input);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe(expected);
+    }
+  });
+
+  it('trims whitespace and normalizes case', () => {
+    const result = mapVideoStatus('  QUEUED  ');
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe('queued');
+    }
+  });
+
+  it('returns PROVIDER_UPSTREAM_ERROR for unknown status', () => {
+    const result = mapVideoStatus('unknown_state');
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_UPSTREAM_ERROR');
+      expect(result.error.message).toContain('unknown_state');
+    }
+  });
+});
+
+describe('mapInitialStatus', () => {
+  it('returns queued when status is undefined', () => {
+    const result = mapInitialStatus(undefined);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe('queued');
+    }
+  });
+
+  it('returns queued when status is empty string', () => {
+    const result = mapInitialStatus('');
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe('queued');
+    }
+  });
+
+  it('returns queued when status is whitespace-only', () => {
+    const result = mapInitialStatus('   ');
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe('queued');
+    }
+  });
+
+  it.each([
+    ['queued', 'queued'],
+    ['pending', 'queued'],
+    ['submitted', 'queued'],
+    ['running', 'running'],
+    ['processing', 'running'],
+    ['in_progress', 'running'],
+  ])('maps "%s" to "%s"', (input, expected) => {
+    const result = mapInitialStatus(input);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value).toBe(expected);
+    }
+  });
+
+  it('returns error for status that is not queued or running', () => {
+    const result = mapInitialStatus('completed');
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_UPSTREAM_ERROR');
+    }
+  });
+});
+
+describe('toIsoTimestamp', () => {
+  it('converts epoch seconds to ISO string', () => {
+    const epochSeconds = 1700000000;
+    const result = toIsoTimestamp(epochSeconds);
+    expect(result).toBe(new Date(epochSeconds * 1000).toISOString());
+  });
+
+  it('converts epoch milliseconds to ISO string', () => {
+    const epochMs = 1700000000000;
+    const result = toIsoTimestamp(epochMs);
+    expect(result).toBe(new Date(epochMs).toISOString());
+  });
+
+  it('converts numeric string to ISO string', () => {
+    const result = toIsoTimestamp('1700000000');
+    expect(result).toBe(new Date(1700000000 * 1000).toISOString());
+  });
+
+  it('converts ISO string to ISO string', () => {
+    const isoString = '2024-01-15T12:00:00.000Z';
+    const result = toIsoTimestamp(isoString);
+    expect(result).toBe(new Date(isoString).toISOString());
+  });
+
+  it('returns current time for undefined', () => {
+    const before = Date.now();
+    const result = toIsoTimestamp(undefined);
+    const after = Date.now();
+    const resultMs = new Date(result).getTime();
+    expect(resultMs).toBeGreaterThanOrEqual(before);
+    expect(resultMs).toBeLessThanOrEqual(after);
+  });
+
+  it('returns current time for non-parsable string', () => {
+    const before = Date.now();
+    const result = toIsoTimestamp('not-a-date');
+    const after = Date.now();
+    const resultMs = new Date(result).getTime();
+    expect(resultMs).toBeGreaterThanOrEqual(before);
+    expect(resultMs).toBeLessThanOrEqual(after);
+  });
+
+  it('returns current time for NaN number', () => {
+    const before = Date.now();
+    const result = toIsoTimestamp(NaN);
+    const after = Date.now();
+    const resultMs = new Date(result).getTime();
+    expect(resultMs).toBeGreaterThanOrEqual(before);
+    expect(resultMs).toBeLessThanOrEqual(after);
+  });
+});
+
+describe('mapVideoJobSnapshot', () => {
+  it('maps a succeeded response with video output', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: 'task-1',
+      status: 'completed',
+      video_url: 'https://cdn.test/video.mp4',
+      mime_type: 'video/mp4',
+      bytes: 2048,
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.jobId).toBe('task-1');
+      expect(result.value.status).toBe('succeeded');
+      expect(result.value.output).toEqual({
+        kind: 'uri',
+        uri: 'https://cdn.test/video.mp4',
+        mimeType: 'video/mp4',
+        bytes: 2048,
+      });
+      expect(result.value.error).toBeUndefined();
+    }
+  });
+
+  it('maps a failed response with error message', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: 'task-2',
+      status: 'failed',
+      error_message: 'Content policy violation',
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.status).toBe('failed');
+      expect(result.value.error?.code).toBe('PROVIDER_UPSTREAM_ERROR');
+      expect(result.value.error?.message).toBe('Content policy violation');
+      expect(result.value.output).toBeUndefined();
+    }
+  });
+
+  it('returns error when task id is empty', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: '',
+      status: 'completed',
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_UPSTREAM_ERROR');
+      expect(result.error.message).toContain('missing task id');
+    }
+  });
+
+  it('returns error when task id is whitespace-only', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: '   ',
+      status: 'completed',
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(false);
+  });
+
+  it('returns error for unknown status', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: 'task-3',
+      status: 'bizarre_state',
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_UPSTREAM_ERROR');
+    }
+  });
+
+  it('prefers updated_at over created_at for timestamp', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: 'task-4',
+      status: 'queued',
+      created_at: 1700000000,
+      updated_at: 1700001000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.updatedAt).toBe(new Date(1700001000 * 1000).toISOString());
+    }
+  });
+
+  it('falls back to created_at when updated_at is absent', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: 'task-5',
+      status: 'queued',
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.updatedAt).toBe(new Date(1700000000 * 1000).toISOString());
+    }
+  });
+
+  it('resolves video url from content.video_url when direct url is absent', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: 'task-6',
+      status: 'succeeded',
+      content: { video_url: 'https://cdn.test/content-video.mp4' },
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.output?.uri).toBe('https://cdn.test/content-video.mp4');
+    }
+  });
+
+  it('prefers direct video_url over content.video_url', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: 'task-7',
+      status: 'succeeded',
+      video_url: 'https://cdn.test/direct.mp4',
+      content: { video_url: 'https://cdn.test/content.mp4' },
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.output?.uri).toBe('https://cdn.test/direct.mp4');
+    }
+  });
+
+  it('returns undefined output when no video url is present', () => {
+    const response: IBytedanceVideoTaskResponse = {
+      id: 'task-8',
+      status: 'queued',
+      created_at: 1700000000,
+    };
+    const result = mapVideoJobSnapshot(response);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.output).toBeUndefined();
+    }
+  });
+});

package/src/bytedance/status-mapper.ts

@@ -0,0 +1,141 @@
+import type { TProviderMediaResult, IVideoJobSnapshot } from '@robota-sdk/agent-core';
+import type { IBytedanceVideoTaskResponse } from './types';
+
+/** Threshold (in milliseconds) above which a numeric timestamp is treated as milliseconds rather than seconds. */
+const MILLISECOND_EPOCH_THRESHOLD = 1_000_000_000_000;
+
+/** Conversion factor from seconds to milliseconds. */
+const MS_PER_SECOND = 1000;
+
+/** Maps a Bytedance video task response into a normalized job snapshot. */
+export function mapVideoJobSnapshot(
+  response: IBytedanceVideoTaskResponse,
+): TProviderMediaResult<IVideoJobSnapshot> {
+  if (response.id.trim().length === 0) {
+    return {
+      ok: false,
+      error: {
+        code: 'PROVIDER_UPSTREAM_ERROR',
+        message: 'Bytedance video job response is missing task id.',
+      },
+    };
+  }
+  const normalizedStatusResult = mapVideoStatus(response.status);
+  if (!normalizedStatusResult.ok) {
+    return normalizedStatusResult;
+  }
+  return {
+    ok: true,
+    value: {
+      jobId: response.id,
+      status: normalizedStatusResult.value,
+      output: mapOutput(response),
+      error:
+        normalizedStatusResult.value === 'failed' && response.error_message
+          ? { code: 'PROVIDER_UPSTREAM_ERROR', message: response.error_message }
+          : undefined,
+      updatedAt: toIsoTimestamp(response.updated_at ?? response.created_at),
+    },
+  };
+}
+
+/** Maps a Bytedance status string to a normalized video job status. */
+export function mapVideoStatus(status: string): TProviderMediaResult<IVideoJobSnapshot['status']> {
+  const normalized = status.trim().toLowerCase();
+  if (normalized === 'queued' || normalized === 'pending' || normalized === 'submitted') {
+    return { ok: true, value: 'queued' };
+  }
+  if (normalized === 'running' || normalized === 'processing' || normalized === 'in_progress') {
+    return { ok: true, value: 'running' };
+  }
+  if (normalized === 'succeeded' || normalized === 'success' || normalized === 'completed') {
+    return { ok: true, value: 'succeeded' };
+  }
+  if (normalized === 'failed' || normalized === 'error') {
+    return { ok: true, value: 'failed' };
+  }
+  if (normalized === 'cancelled' || normalized === 'canceled') {
+    return { ok: true, value: 'cancelled' };
+  }
+  return {
+    ok: false,
+    error: {
+      code: 'PROVIDER_UPSTREAM_ERROR',
+      message: `Unexpected video job status from Bytedance: ${status}`,
+    },
+  };
+}
+
+/** Maps the initial createVideo status to queued or running. */
+export function mapInitialStatus(
+  statusValue: string | undefined,
+): TProviderMediaResult<'queued' | 'running'> {
+  if (typeof statusValue !== 'string' || statusValue.trim().length === 0) {
+    return { ok: true, value: 'queued' };
+  }
+  const normalizedStatus = statusValue.trim().toLowerCase();
+  if (
+    normalizedStatus === 'queued' ||
+    normalizedStatus === 'pending' ||
+    normalizedStatus === 'submitted'
+  ) {
+    return { ok: true, value: 'queued' };
+  }
+  if (
+    normalizedStatus === 'running' ||
+    normalizedStatus === 'processing' ||
+    normalizedStatus === 'in_progress'
+  ) {
+    return { ok: true, value: 'running' };
+  }
+  return {
+    ok: false,
+    error: {
+      code: 'PROVIDER_UPSTREAM_ERROR',
+      message: `Unexpected createVideo status from Bytedance: ${statusValue}`,
+    },
+  };
+}
+
+/** Converts a numeric or string timestamp to ISO 8601 format. */
+export function toIsoTimestamp(value: string | number | undefined): string {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const numericTimestamp = value > MILLISECOND_EPOCH_THRESHOLD ? value : value * MS_PER_SECOND;
+    const date = new Date(numericTimestamp);
+    if (!Number.isNaN(date.getTime())) {
+      return date.toISOString();
+    }
+  }
+  if (typeof value === 'string' && value.trim().length > 0) {
+    const maybeNumeric = Number(value);
+    if (Number.isFinite(maybeNumeric)) {
+      return toIsoTimestamp(maybeNumeric);
+    }
+    const parsedDate = new Date(value);
+    if (!Number.isNaN(parsedDate.getTime())) {
+      return parsedDate.toISOString();
+    }
+  }
+  return new Date().toISOString();
+}
+
+function mapOutput(response: IBytedanceVideoTaskResponse): IVideoJobSnapshot['output'] {
+  const directVideoUrl =
+    typeof response.video_url === 'string' && response.video_url.trim().length > 0
+      ? response.video_url
+      : undefined;
+  const contentVideoUrl =
+    typeof response.content?.video_url === 'string' && response.content.video_url.trim().length > 0
+      ? response.content.video_url
+      : undefined;
+  const resolvedVideoUrl = directVideoUrl ?? contentVideoUrl;
+  if (typeof resolvedVideoUrl !== 'string') {
+    return undefined;
+  }
+  return {
+    kind: 'uri',
+    uri: resolvedVideoUrl,
+    mimeType: response.mime_type,
+    bytes: response.bytes,
+  };
+}

package/src/bytedance/types.ts

@@ -0,0 +1,68 @@
+import type { TUniversalValue } from '@robota-sdk/agent-core';
+
+export interface IBytedanceProviderOptions {
+  apiKey: string;
+  baseUrl: string;
+  createVideoPath?: string;
+  getVideoTaskPathTemplate?: string;
+  cancelVideoTaskPathTemplate?: string;
+  cancelVideoTaskMethod?: 'POST' | 'DELETE';
+  timeoutMs?: number;
+  defaultHeaders?: Record<string, string>;
+}
+
+export interface IBytedanceTaskContentText {
+  type: 'text';
+  text: string;
+}
+
+export interface IBytedanceTaskContentImageUrl {
+  type: 'image_url';
+  image_url: {
+    url: string;
+  };
+}
+
+export type TBytedanceTaskContent = IBytedanceTaskContentText | IBytedanceTaskContentImageUrl;
+
+export interface IBytedanceCreateVideoTaskRequest {
+  model: string;
+  content: TBytedanceTaskContent[];
+  generate_audio?: boolean;
+  ratio?: string;
+  duration?: number;
+  watermark?: boolean;
+}
+
+export interface IBytedanceCreateVideoTaskResponse {
+  id: string;
+  status?: string;
+  created_at?: string | number;
+}
+
+export interface IBytedanceTaskContentVideoUrl {
+  type: 'video_url';
+  video_url: {
+    url: string;
+  };
+}
+
+export interface IBytedanceVideoTaskResponse {
+  id: string;
+  status: string;
+  video_url?: string;
+  content?: {
+    video_url?: string;
+  };
+  mime_type?: string;
+  bytes?: number;
+  error_message?: string;
+  created_at?: string | number;
+  updated_at?: string | number;
+}
+
+export interface IBytedanceApiErrorResponse {
+  code?: string;
+  message?: string;
+  details?: Record<string, TUniversalValue>;
+}

package/src/deepseek/defaults.ts

@@ -0,0 +1,4 @@
+export const DEFAULT_DEEPSEEK_PROVIDER_MODEL = 'deepseek-v4-flash';
+export const DEFAULT_DEEPSEEK_PROVIDER_API_KEY_ENV = 'DEEPSEEK_API_KEY';
+export const DEFAULT_DEEPSEEK_PROVIDER_API_KEY_REFERENCE = `$ENV:${DEFAULT_DEEPSEEK_PROVIDER_API_KEY_ENV}`;
+export const DEFAULT_DEEPSEEK_PROVIDER_BASE_URL = 'https://api.deepseek.com';

package/src/deepseek/index.ts

@@ -0,0 +1,22 @@
+export { DeepSeekProvider } from './provider';
+export { createDeepSeekProviderDefinition } from './provider-definition';
+export {
+  DEFAULT_DEEPSEEK_PROVIDER_API_KEY_ENV,
+  DEFAULT_DEEPSEEK_PROVIDER_API_KEY_REFERENCE,
+  DEFAULT_DEEPSEEK_PROVIDER_BASE_URL,
+  DEFAULT_DEEPSEEK_PROVIDER_MODEL,
+} from './defaults';
+export { refreshDeepSeekModelCatalog } from './model-catalog-refresh';
+export {
+  DEEPSEEK_DEPRECATED_ALIAS_RETIREMENT_DATE,
+  DEEPSEEK_MODEL_CATALOG_SOURCE_URL,
+  DEEPSEEK_MODEL_LAST_VERIFIED_AT,
+  DEEPSEEK_MODEL_LIST_SOURCE_URL,
+} from './model-catalog';
+export type {
+  IDeepSeekProviderOptions,
+  IDeepSeekThinkingConfig,
+  TDeepSeekProviderOptionValue,
+  TDeepSeekReasoningEffort,
+  TDeepSeekThinkingMode,
+} from './types';

package/src/deepseek/model-catalog-refresh.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from 'vitest';
+import { refreshDeepSeekModelCatalog } from './model-catalog-refresh';
+
+describe('refreshDeepSeekModelCatalog', () => {
+  it('maps the live DeepSeek /models response into provider model catalog entries', async () => {
+    const fetcher = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        data: [
+          { id: 'deepseek-v4-flash', object: 'model', owned_by: 'deepseek' },
+          { id: 'deepseek-v4-pro', object: 'model', owned_by: 'deepseek' },
+          { id: 'custom-deepseek', object: 'model', owned_by: 'deepseek' },
+        ],
+      }),
+    }));
+
+    const catalog = await refreshDeepSeekModelCatalog(
+      {
+        baseURL: 'https://api.deepseek.com/',
+        apiKey: 'deepseek-key',
+      },
+      fetcher,
+    );
+
+    expect(fetcher).toHaveBeenCalledWith('https://api.deepseek.com/models', {
+      headers: {
+        Authorization: 'Bearer deepseek-key',
+      },
+    });
+    expect(catalog.status).toBe('live');
+    expect(catalog.entries?.map((entry) => entry.id)).toEqual([
+      'deepseek-v4-flash',
+      'deepseek-v4-pro',
+      'custom-deepseek',
+    ]);
+    expect(catalog.entries?.[0]).toMatchObject({
+      displayName: 'DeepSeek V4 Flash',
+      capabilities: ['tools', 'reasoning', 'json_schema', 'streaming'],
+    });
+  });
+
+  it('returns an unavailable catalog when the live model refresh fails', async () => {
+    const fetcher = vi.fn(async () => ({
+      ok: false,
+      status: 401,
+      json: async () => ({ data: [] }),
+    }));
+
+    const catalog = await refreshDeepSeekModelCatalog({}, fetcher);
+
+    expect(catalog).toMatchObject({
+      status: 'unavailable',
+      message: 'DeepSeek model refresh failed: HTTP 401',
+    });
+  });
+});

package/src/deepseek/model-catalog-refresh.ts

@@ -0,0 +1,105 @@
+import type {
+  IProviderModelCatalog,
+  IProviderModelCatalogEntry,
+  IProviderProfileConfig,
+} from '@robota-sdk/agent-core';
+import { DEFAULT_DEEPSEEK_PROVIDER_BASE_URL } from './defaults';
+import {
+  DEEPSEEK_MODEL_CATALOG_SOURCE_URL,
+  DEEPSEEK_MODEL_LAST_VERIFIED_AT,
+  getDeepSeekFallbackModelCatalogEntry,
+} from './model-catalog';
+
+export interface IDeepSeekModelsResponse {
+  data?: Array<{
+    id?: string;
+    object?: string;
+    owned_by?: string;
+  }>;
+}
+
+export interface IDeepSeekFetchInit {
+  headers?: Record<string, string>;
+}
+
+export interface IDeepSeekFetchResponse {
+  ok: boolean;
+  status: number;
+  json: () => Promise<IDeepSeekModelsResponse>;
+}
+
+export type TDeepSeekFetch = (
+  url: string,
+  init?: IDeepSeekFetchInit,
+) => Promise<IDeepSeekFetchResponse>;
+
+export async function refreshDeepSeekModelCatalog(
+  profile: IProviderProfileConfig,
+  fetcher: TDeepSeekFetch = defaultDeepSeekFetch,
+): Promise<IProviderModelCatalog> {
+  const baseURL = trimTrailingSlash(profile.baseURL ?? DEFAULT_DEEPSEEK_PROVIDER_BASE_URL);
+  const url = `${baseURL}/models`;
+  const response = await fetcher(url, buildFetchInit(profile.apiKey));
+
+  if (!response.ok) {
+    return {
+      status: 'unavailable',
+      sourceUrl: DEEPSEEK_MODEL_CATALOG_SOURCE_URL,
+      message: `DeepSeek model refresh failed: HTTP ${response.status}`,
+    };
+  }
+
+  const body = await response.json();
+  const entries = (body.data ?? [])
+    .map((model) => model.id)
+    .filter((id): id is string => typeof id === 'string' && id.length > 0)
+    .map(toModelCatalogEntry);
+
+  return {
+    status: 'live',
+    sourceUrl: DEEPSEEK_MODEL_CATALOG_SOURCE_URL,
+    lastVerifiedAt: DEEPSEEK_MODEL_LAST_VERIFIED_AT,
+    entries,
+  };
+}
+
+function buildFetchInit(apiKey: string | undefined): IDeepSeekFetchInit | undefined {
+  if (!apiKey) {
+    return undefined;
+  }
+  return {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+    },
+  };
+}
+
+function toModelCatalogEntry(id: string): IProviderModelCatalogEntry {
+  return (
+    getDeepSeekFallbackModelCatalogEntry(id) ?? {
+      id,
+      displayName: id,
+      lifecycle: 'active',
+      sourceUrl: DEEPSEEK_MODEL_CATALOG_SOURCE_URL,
+      lastVerifiedAt: DEEPSEEK_MODEL_LAST_VERIFIED_AT,
+    }
+  );
+}
+
+function trimTrailingSlash(value: string): string {
+  return value.replace(/\/$/, '');
+}
+
+async function defaultDeepSeekFetch(
+  url: string,
+  init?: IDeepSeekFetchInit,
+): Promise<IDeepSeekFetchResponse> {
+  const response = await fetch(url, {
+    ...(init?.headers !== undefined && { headers: init.headers }),
+  });
+  return {
+    ok: response.ok,
+    status: response.status,
+    json: () => response.json() as Promise<IDeepSeekModelsResponse>,
+  };
+}