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

package/src/bytedance/provider.spec.ts

@@ -0,0 +1,320 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { BytedanceProvider } from './provider';
+
+describe('BytedanceProvider', () => {
+  const fetchMock = vi.fn();
+
+  beforeEach(() => {
+    fetchMock.mockReset();
+    vi.stubGlobal('fetch', fetchMock);
+  });
+
+  it('maps createVideo response to accepted job shape', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ id: 'task-1', status: 'queued' }),
+    });
+
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({
+      prompt: 'test prompt',
+      model: 'seedance-2.0',
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      throw new Error('Expected successful result');
+    }
+    expect(result.value.jobId).toBe('task-1');
+    expect(result.value.status).toBe('queued');
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://api.byteplus.test/contents/generations/tasks',
+      expect.objectContaining({
+        method: 'POST',
+      }),
+    );
+  });
+
+  it('maps createVideo response without status as queued', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ id: 'task-no-status' }),
+    });
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({
+      prompt: 'test prompt',
+      model: 'seedance-1-5-pro-251215',
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      throw new Error('Expected successful result');
+    }
+    expect(result.value.status).toBe('queued');
+    expect(result.value.jobId).toBe('task-no-status');
+  });
+
+  it('maps getVideoJob success with output uri', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      text: async () =>
+        JSON.stringify({
+          id: 'task-2',
+          status: 'completed',
+          video_url: 'https://cdn.test/video.mp4',
+          mime_type: 'video/mp4',
+          bytes: 1024,
+        }),
+    });
+
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.getVideoJob('job-2');
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      throw new Error('Expected successful result');
+    }
+    expect(result.value.status).toBe('succeeded');
+    expect(result.value.output?.uri).toBe('https://cdn.test/video.mp4');
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://api.byteplus.test/contents/generations/tasks/job-2',
+      expect.objectContaining({
+        method: 'GET',
+      }),
+    );
+  });
+
+  it('maps 404 response to PROVIDER_JOB_NOT_FOUND', async () => {
+    fetchMock.mockResolvedValue({
+      ok: false,
+      status: 404,
+      text: async () => JSON.stringify({ message: 'not found' }),
+    });
+
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.getVideoJob('missing-job');
+
+    expect(result.ok).toBe(false);
+    if (result.ok) {
+      throw new Error('Expected failed result');
+    }
+    expect(result.error.code).toBe('PROVIDER_JOB_NOT_FOUND');
+  });
+
+  it('rejects createVideo with empty prompt', async () => {
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({ prompt: '', model: 'seedance-2.0' });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_INVALID_REQUEST');
+    }
+  });
+
+  it('rejects createVideo with empty model', async () => {
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({ prompt: 'test', model: '' });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_INVALID_REQUEST');
+    }
+  });
+
+  it('rejects createVideo when seed is provided', async () => {
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({ prompt: 'test', model: 'seedance-2.0', seed: 42 });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_INVALID_REQUEST');
+    }
+  });
+
+  it('rejects createVideo with empty task id in response', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ id: '', status: 'queued' }),
+    });
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({ prompt: 'test', model: 'seedance-2.0' });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_UPSTREAM_ERROR');
+    }
+  });
+
+  it('includes image URI content in createVideo payload', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ id: 'task-img', status: 'queued' }),
+    });
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({
+      prompt: 'animate this',
+      model: 'seedance-2.0',
+      inputImages: [{ kind: 'uri', uri: 'https://example.com/img.png' }],
+    });
+    expect(result.ok).toBe(true);
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+    expect(body.content).toHaveLength(2);
+    expect(body.content[1].type).toBe('image_url');
+    expect(body.content[1].image_url.url).toBe('https://example.com/img.png');
+  });
+
+  it('includes inline base64 image content in createVideo payload', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ id: 'task-b64', status: 'queued' }),
+    });
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({
+      prompt: 'animate this',
+      model: 'seedance-2.0',
+      inputImages: [{ kind: 'inline', data: 'aGVsbG8=', mimeType: 'image/png' }],
+    });
+    expect(result.ok).toBe(true);
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+    expect(body.content[1].image_url.url).toBe('data:image/png;base64,aGVsbG8=');
+  });
+
+  it('rejects createVideo with empty image URI', async () => {
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({
+      prompt: 'test',
+      model: 'seedance-2.0',
+      inputImages: [{ kind: 'uri', uri: '' }],
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_INVALID_REQUEST');
+    }
+  });
+
+  it('rejects createVideo with empty inline image data', async () => {
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({
+      prompt: 'test',
+      model: 'seedance-2.0',
+      inputImages: [{ kind: 'inline', data: '', mimeType: 'image/png' }],
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_INVALID_REQUEST');
+    }
+  });
+
+  it('rejects createVideo with empty inline image mimeType', async () => {
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.createVideo({
+      prompt: 'test',
+      model: 'seedance-2.0',
+      inputImages: [{ kind: 'inline', data: 'aGVsbG8=', mimeType: '' }],
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_INVALID_REQUEST');
+    }
+  });
+
+  it('rejects getVideoJob with empty jobId', async () => {
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.getVideoJob('');
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_INVALID_REQUEST');
+    }
+  });
+
+  it('rejects cancelVideoJob with empty jobId', async () => {
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.cancelVideoJob('');
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('PROVIDER_INVALID_REQUEST');
+    }
+  });
+
+  it('uses POST method for cancelVideoJob when configured', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      text: async () => JSON.stringify({ id: 'task-cancel', status: 'cancelled' }),
+    });
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+      cancelVideoTaskMethod: 'POST',
+    });
+    await provider.cancelVideoJob('task-cancel');
+    expect(fetchMock).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({ method: 'POST' }),
+    );
+  });
+
+  it('uses DELETE by default for cancelVideoJob', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      text: async () =>
+        JSON.stringify({
+          id: 'task-3',
+          status: 'cancelled',
+        }),
+    });
+    const provider = new BytedanceProvider({
+      apiKey: 'test-key',
+      baseUrl: 'https://api.byteplus.test',
+    });
+    const result = await provider.cancelVideoJob('task-3');
+
+    expect(result.ok).toBe(true);
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://api.byteplus.test/contents/generations/tasks/task-3',
+      expect.objectContaining({
+        method: 'DELETE',
+      }),
+    );
+  });
+});

package/src/bytedance/provider.ts

@@ -0,0 +1,171 @@
+import type {
+  IInlineImageInputSource,
+  IUriImageInputSource,
+  TProviderMediaResult,
+  IVideoGenerationProvider,
+  IVideoGenerationRequest,
+  IVideoJobAccepted,
+  IVideoJobSnapshot,
+} from '@robota-sdk/agent-core';
+import type {
+  IBytedanceCreateVideoTaskRequest,
+  IBytedanceCreateVideoTaskResponse,
+  IBytedanceProviderOptions,
+  IBytedanceVideoTaskResponse,
+  TBytedanceTaskContent,
+} from './types';
+import { requestJson } from './http-client';
+import { mapVideoJobSnapshot, mapInitialStatus, toIsoTimestamp } from './status-mapper';
+
+const DEFAULT_CREATE_VIDEO_PATH = '/contents/generations/tasks';
+const DEFAULT_GET_VIDEO_TASK_PATH_TEMPLATE = '/contents/generations/tasks/{taskId}';
+const DEFAULT_CANCEL_VIDEO_TASK_PATH_TEMPLATE = '/contents/generations/tasks/{taskId}';
+
+export class BytedanceProvider implements IVideoGenerationProvider {
+  private readonly options: IBytedanceProviderOptions;
+
+  public constructor(options: IBytedanceProviderOptions) {
+    this.options = options;
+  }
+
+  public async createVideo(
+    request: IVideoGenerationRequest,
+  ): Promise<TProviderMediaResult<IVideoJobAccepted>> {
+    if (request.prompt.trim().length === 0) {
+      return buildInvalidRequestError('Video generation requires non-empty prompt.');
+    }
+    if (request.model.trim().length === 0) {
+      return buildInvalidRequestError('Video generation requires non-empty model.');
+    }
+    if (typeof request.seed === 'number') {
+      return buildInvalidRequestError(
+        'ModelArk Seedance provider does not support seed field in current contract.',
+      );
+    }
+
+    const contentResult = this.buildContentPayload(request.prompt, request.inputImages);
+    if (!contentResult.ok) {
+      return contentResult;
+    }
+
+    const payload: IBytedanceCreateVideoTaskRequest = {
+      model: request.model.trim(),
+      content: contentResult.value,
+      duration: request.durationSeconds,
+      ratio: request.aspectRatio,
+    };
+
+    const responseResult = await requestJson<IBytedanceCreateVideoTaskResponse>(this.options, {
+      path: this.options.createVideoPath ?? DEFAULT_CREATE_VIDEO_PATH,
+      method: 'POST',
+      body: JSON.stringify(payload),
+    });
+    if (!responseResult.ok) {
+      return responseResult;
+    }
+
+    if (responseResult.value.id.trim().length === 0) {
+      return buildUpstreamError('Bytedance createVideo response is missing task id.');
+    }
+    const mappedStatus = mapInitialStatus(responseResult.value.status);
+    if (!mappedStatus.ok) {
+      return mappedStatus;
+    }
+    return {
+      ok: true,
+      value: {
+        jobId: responseResult.value.id,
+        status: mappedStatus.value,
+        createdAt: toIsoTimestamp(responseResult.value.created_at),
+      },
+    };
+  }
+
+  public async getVideoJob(jobId: string): Promise<TProviderMediaResult<IVideoJobSnapshot>> {
+    if (jobId.trim().length === 0) {
+      return buildInvalidRequestError('Video job lookup requires non-empty jobId.');
+    }
+
+    const responseResult = await requestJson<IBytedanceVideoTaskResponse>(this.options, {
+      path: buildPath(
+        this.options.getVideoTaskPathTemplate ?? DEFAULT_GET_VIDEO_TASK_PATH_TEMPLATE,
+        jobId,
+      ),
+      method: 'GET',
+    });
+    if (!responseResult.ok) {
+      return responseResult;
+    }
+    return mapVideoJobSnapshot(responseResult.value);
+  }
+
+  public async cancelVideoJob(jobId: string): Promise<TProviderMediaResult<IVideoJobSnapshot>> {
+    if (jobId.trim().length === 0) {
+      return buildInvalidRequestError('Video job cancellation requires non-empty jobId.');
+    }
+
+    const cancelMethod = this.options.cancelVideoTaskMethod ?? 'DELETE';
+    const responseResult = await requestJson<IBytedanceVideoTaskResponse>(this.options, {
+      path: buildPath(
+        this.options.cancelVideoTaskPathTemplate ?? DEFAULT_CANCEL_VIDEO_TASK_PATH_TEMPLATE,
+        jobId,
+      ),
+      method: cancelMethod,
+    });
+    if (!responseResult.ok) {
+      return responseResult;
+    }
+    return mapVideoJobSnapshot(responseResult.value);
+  }
+
+  private buildContentPayload(
+    prompt: string,
+    inputImages: IVideoGenerationRequest['inputImages'],
+  ): TProviderMediaResult<TBytedanceTaskContent[]> {
+    const normalizedPrompt = prompt.trim();
+    if (normalizedPrompt.length === 0) {
+      return buildInvalidRequestError('Video generation requires non-empty prompt.');
+    }
+    const content: TBytedanceTaskContent[] = [{ type: 'text', text: normalizedPrompt }];
+    if (Array.isArray(inputImages)) {
+      for (const image of inputImages) {
+        const imageUrlResult = toContentImageUrl(image);
+        if (!imageUrlResult.ok) {
+          return imageUrlResult;
+        }
+        content.push({ type: 'image_url', image_url: { url: imageUrlResult.value } });
+      }
+    }
+    return { ok: true, value: content };
+  }
+}
+
+function buildPath(template: string, taskId: string): string {
+  return template.replace('{taskId}', encodeURIComponent(taskId));
+}
+
+function buildInvalidRequestError(message: string): TProviderMediaResult<never> {
+  return { ok: false, error: { code: 'PROVIDER_INVALID_REQUEST', message } };
+}
+
+function buildUpstreamError(message: string): TProviderMediaResult<never> {
+  return { ok: false, error: { code: 'PROVIDER_UPSTREAM_ERROR', message } };
+}
+
+function toContentImageUrl(
+  image: IInlineImageInputSource | IUriImageInputSource,
+): TProviderMediaResult<string> {
+  if (image.kind === 'uri') {
+    if (image.uri.trim().length === 0) {
+      return buildInvalidRequestError('Image uri must be non-empty.');
+    }
+    return { ok: true, value: image.uri };
+  }
+  if (image.data.trim().length === 0) {
+    return buildInvalidRequestError('Inline image data must be non-empty.');
+  }
+  if (image.mimeType.trim().length === 0) {
+    return buildInvalidRequestError('Inline image mimeType must be non-empty.');
+  }
+  return { ok: true, value: `data:${image.mimeType};base64,${image.data}` };
+}