@vertesia/workflow 1.1.1-dev.20260505.163000Z → 1.3.0-dev.20260620.061059Z

package/src/activities/media/transcribeMediaWithGladia.test.ts

@@ -1,15 +1,24 @@
-import { CompleteAsyncError } from "@temporalio/activity";
-import { MockActivityEnvironment } from "@temporalio/testing";
-import type { VertesiaClient } from "@vertesia/client";
-import { AUDIO_RENDITION_NAME, ContentEventName, ContentNature, DSLActivityExecutionPayload } from "@vertesia/common";
-import type { ActivityContext } from "@vertesia/workflow";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { TextExtractionStatus } from "../../result-types.js";
-import { transcribeMedia, TranscriptMediaParams, TranscriptMediaResult } from "./transcribeMediaWithGladia.js";
+import { CompleteAsyncError } from '@temporalio/activity';
+import { MockActivityEnvironment } from '@temporalio/testing';
+import type { VertesiaClient } from '@vertesia/client';
+import {
+    AUDIO_RENDITION_NAME,
+    ContentEventName,
+    ContentNature,
+    type DSLActivityExecutionPayload,
+} from '@vertesia/common';
+import type { ActivityContext } from '@vertesia/workflow';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { TextExtractionStatus } from '../../result-types.js';
+import {
+    type TranscriptMediaParams,
+    type TranscriptMediaResult,
+    transcribeMedia,
+} from './transcribeMediaWithGladia.js';
 
 // Mock setupActivity from the relative path used by the activity
-vi.mock("../../dsl/setup/ActivityContext.js", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("../../dsl/setup/ActivityContext.js")>();
+vi.mock('../../dsl/setup/ActivityContext.js', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('../../dsl/setup/ActivityContext.js')>();
     return {
         ...actual,
         setupActivity: vi.fn(),
@@ -17,15 +26,14 @@ vi.mock("../../dsl/setup/ActivityContext.js", async (importOriginal) => {
 });
 
 // Mock FetchClient as a constructor
-vi.mock("@vertesia/api-fetch-client", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("@vertesia/api-fetch-client")>();
+vi.mock('@vertesia/api-fetch-client', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('@vertesia/api-fetch-client')>();
     return {
         ...actual,
         FetchClient: vi.fn(),
     };
 });
 
-
 let testEnv: MockActivityEnvironment;
 
 beforeAll(async () => {
@@ -40,44 +48,46 @@ beforeEach(() => {
 const createTestPayload = (
     params: TranscriptMediaParams,
     objectId?: string,
-    fileInput?: { url: string; mimetype: string }
+    fileInput?: { url: string; mimetype: string },
 ): DSLActivityExecutionPayload<TranscriptMediaParams> => {
     return {
-        auth_token: process.env.VERTESIA_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature",
-        account_id: "test-account",
-        project_id: "test-project",
+        auth_token:
+            process.env.VERTESIA_KEY ||
+            'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature',
+        account_id: 'test-account',
+        project_id: 'test-project',
         params,
         config: {
-            studio_url: "http://mock-studio",
-            store_url: "http://mock-store",
+            studio_url: 'http://mock-studio',
+            store_url: 'http://mock-store',
         },
-        workflow_name: "test-workflow",
+        workflow_name: 'test-workflow',
         event: ContentEventName.create,
         objectIds: objectId ? [objectId] : [],
         input: fileInput
             ? { inputType: 'files' as const, files: [fileInput] }
             : objectId
-            ? { inputType: 'objectIds' as const, objectIds: [objectId] }
-            : undefined,
+              ? { inputType: 'objectIds' as const, objectIds: [objectId] }
+              : undefined,
         vars: {},
-        activity: { name: "TranscribeMedia", params }
+        activity: { name: 'TranscribeMedia', params: params as unknown as Record<string, unknown> },
     };
 };
 
-describe("TranscribeMedia", () => {
-    it("should send transcription request in object mode", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+describe('TranscribeMedia', () => {
+    it('should send transcription request in object mode', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
             post: vi.fn().mockResolvedValue({
-                id: "test-transcription-id",
-                result_url: "https://api.gladia.io/v2/transcription/test-transcription-id",
+                id: 'test-transcription-id',
+                result_url: 'https://api.gladia.io/v2/transcription/test-transcription-id',
             }),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -85,70 +95,70 @@ describe("TranscribeMedia", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
             objects: {
                 retrieve: vi.fn().mockResolvedValue({
                     content: {
-                        source: "gs://test-bucket/audio.mp3",
-                        type: "audio/mpeg",
+                        source: 'gs://test-bucket/audio.mp3',
+                        type: 'audio/mpeg',
                     },
                     text: null,
                 }),
             },
             files: {
                 getDownloadUrl: vi.fn().mockResolvedValue({
-                    url: "https://download.example.com/audio.mp3",
+                    url: 'https://download.example.com/audio.mp3',
                 }),
             },
             store: {
-                baseUrl: "http://mock-store",
+                baseUrl: 'http://mock-store',
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {};
+        const params = {} satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
 
         await expect(testEnv.run(transcribeMedia, payload)).rejects.toThrow(CompleteAsyncError);
 
-        expect(mockFetchClient.post).toHaveBeenCalledWith("/transcription", {
+        expect(mockFetchClient.post).toHaveBeenCalledWith('/transcription', {
             payload: {
-                audio_url: "https://download.example.com/audio.mp3",
-                callback_url: expect.stringContaining("http://mock-store/webhooks/gladia?task_token="),
+                audio_url: 'https://download.example.com/audio.mp3',
+                callback_url: expect.stringContaining('http://mock-store/webhooks/gladia?task_token='),
                 diarization_enhanced: true,
                 enable_code_switching: true,
                 subtitles: true,
                 subtitles_config: {
-                    formats: ["vtt"],
+                    formats: ['vtt'],
                 },
             },
         });
     });
 
-    it("should use audio rendition for video objects", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+    it('should use audio rendition for video objects', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
             post: vi.fn().mockResolvedValue({
-                id: "test-transcription-id",
-                result_url: "https://api.gladia.io/v2/transcription/test-transcription-id",
+                id: 'test-transcription-id',
+                result_url: 'https://api.gladia.io/v2/transcription/test-transcription-id',
             }),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -156,16 +166,16 @@ describe("TranscribeMedia", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
             objects: {
                 retrieve: vi.fn().mockResolvedValue({
                     content: {
-                        source: "gs://test-bucket/video.mp4",
-                        type: "video/mp4",
+                        source: 'gs://test-bucket/video.mp4',
+                        type: 'video/mp4',
                     },
                     metadata: {
                         type: ContentNature.Video,
@@ -173,7 +183,7 @@ describe("TranscribeMedia", () => {
                             {
                                 name: AUDIO_RENDITION_NAME,
                                 content: {
-                                    source: "gs://test-bucket/audio-rendition.mp3",
+                                    source: 'gs://test-bucket/audio-rendition.mp3',
                                 },
                             },
                         ],
@@ -183,86 +193,86 @@ describe("TranscribeMedia", () => {
             },
             files: {
                 getDownloadUrl: vi.fn().mockResolvedValue({
-                    url: "https://download.example.com/audio-rendition.mp3",
+                    url: 'https://download.example.com/audio-rendition.mp3',
                 }),
             },
             store: {
-                baseUrl: "http://mock-store",
+                baseUrl: 'http://mock-store',
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {};
+        const params = {} satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-video-id",
+            objectId: 'test-video-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(params, "test-video-id");
+        const payload = createTestPayload(params, 'test-video-id');
 
         await expect(testEnv.run(transcribeMedia, payload)).rejects.toThrow(CompleteAsyncError);
 
         // Should use audio rendition source
-        expect(mockClient.files.getDownloadUrl).toHaveBeenCalledWith("gs://test-bucket/audio-rendition.mp3");
+        expect(mockClient.files.getDownloadUrl).toHaveBeenCalledWith('gs://test-bucket/audio-rendition.mp3');
     });
 
-    it("should skip transcription when text already exists", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
+    it('should skip transcription when text already exists', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
 
         const mockClient = {
             projects: {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
+                        api_key: 'test-api-key',
                     }),
                 },
             },
             objects: {
                 retrieve: vi.fn().mockResolvedValue({
                     content: {
-                        source: "gs://test-bucket/audio.mp3",
+                        source: 'gs://test-bucket/audio.mp3',
                     },
-                    text: "Existing transcription text",
+                    text: 'Existing transcription text',
                 }),
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {};
+        const params = {} satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
         const result: TranscriptMediaResult = await testEnv.run(transcribeMedia, payload);
 
         expect(result).toMatchObject({
             hasText: true,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             status: TextExtractionStatus.skipped,
-            message: "text already present and force not enabled",
+            message: 'text already present and force not enabled',
         });
     });
 
-    it("should force transcription when force=true", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+    it('should force transcription when force=true', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
             post: vi.fn().mockResolvedValue({
-                id: "test-transcription-id",
-                result_url: "https://api.gladia.io/v2/transcription/test-transcription-id",
+                id: 'test-transcription-id',
+                result_url: 'https://api.gladia.io/v2/transcription/test-transcription-id',
             }),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -270,60 +280,60 @@ describe("TranscribeMedia", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
             objects: {
                 retrieve: vi.fn().mockResolvedValue({
                     content: {
-                        source: "gs://test-bucket/audio.mp3",
+                        source: 'gs://test-bucket/audio.mp3',
                     },
-                    text: "Existing transcription text",
+                    text: 'Existing transcription text',
                 }),
             },
             files: {
                 getDownloadUrl: vi.fn().mockResolvedValue({
-                    url: "https://download.example.com/audio.mp3",
+                    url: 'https://download.example.com/audio.mp3',
                 }),
             },
             store: {
-                baseUrl: "http://mock-store",
+                baseUrl: 'http://mock-store',
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {
+        const params = {
             force: true,
-        };
+        } satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
 
         await expect(testEnv.run(transcribeMedia, payload)).rejects.toThrow(CompleteAsyncError);
 
         expect(mockFetchClient.post).toHaveBeenCalled();
     });
 
-    it("should send transcription request in file mode", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient } = await import("@vertesia/api-fetch-client");
+    it('should send transcription request in file mode', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient } = await import('@vertesia/api-fetch-client');
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
             post: vi.fn().mockResolvedValue({
-                id: "test-transcription-id",
-                result_url: "https://api.gladia.io/v2/transcription/test-transcription-id",
+                id: 'test-transcription-id',
+                result_url: 'https://api.gladia.io/v2/transcription/test-transcription-id',
             }),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -331,80 +341,78 @@ describe("TranscribeMedia", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
             files: {
                 getDownloadUrl: vi.fn().mockResolvedValue({
-                    url: "https://download.example.com/audio.mp3",
+                    url: 'https://download.example.com/audio.mp3',
                 }),
             },
             store: {
-                baseUrl: "http://mock-store",
+                baseUrl: 'http://mock-store',
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {
-            output_storage_path: "test-storage-path",
-        };
+        const params = {
+            output_storage_path: 'test-storage-path',
+        } satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            file: { url: "gs://test-bucket/audio.mp3", mimetype: "audio/mpeg" },
+            file: { url: 'gs://test-bucket/audio.mp3', mimetype: 'audio/mpeg' },
             inputType: 'files',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(
-            params,
-            undefined,
-            { url: "gs://test-bucket/audio.mp3", mimetype: "audio/mpeg" }
-        );
+        const payload = createTestPayload(params, undefined, {
+            url: 'gs://test-bucket/audio.mp3',
+            mimetype: 'audio/mpeg',
+        });
 
         await expect(testEnv.run(transcribeMedia, payload)).rejects.toThrow(CompleteAsyncError);
 
-        expect(mockClient.files.getDownloadUrl).toHaveBeenCalledWith("gs://test-bucket/audio.mp3");
+        expect(mockClient.files.getDownloadUrl).toHaveBeenCalledWith('gs://test-bucket/audio.mp3');
         expect(mockFetchClient.post).toHaveBeenCalled();
     });
 
-    it("should throw error when output_storage_path is missing in file mode", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
+    it('should throw error when output_storage_path is missing in file mode', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
 
         const mockClient = {
             projects: {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
+                        api_key: 'test-api-key',
                     }),
                 },
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {};
+        const params = {} satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            file: { url: "gs://test-bucket/audio.mp3", mimetype: "audio/mpeg" },
+            file: { url: 'gs://test-bucket/audio.mp3', mimetype: 'audio/mpeg' },
             inputType: 'files',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(
-            params,
-            undefined,
-            { url: "gs://test-bucket/audio.mp3", mimetype: "audio/mpeg" }
-        );
+        const payload = createTestPayload(params, undefined, {
+            url: 'gs://test-bucket/audio.mp3',
+            mimetype: 'audio/mpeg',
+        });
 
         await expect(testEnv.run(transcribeMedia, payload)).rejects.toThrow(
-            "output_storage_path is required when using file input"
+            'output_storage_path is required when using file input',
         );
     });
 
-    it("should handle Gladia integration not enabled", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
+    it('should handle Gladia integration not enabled', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
 
         const mockClient = {
             projects: {
@@ -416,35 +424,35 @@ describe("TranscribeMedia", () => {
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {};
+        const params = {} satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
         const result: TranscriptMediaResult = await testEnv.run(transcribeMedia, payload);
 
         expect(result).toMatchObject({
             hasText: false,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             status: TextExtractionStatus.error,
-            error: "Gladia integration not enabled",
+            error: 'Gladia integration not enabled',
         });
     });
 
-    it("should handle missing source in object mode", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
+    it('should handle missing source in object mode', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
 
         const mockClient = {
             projects: {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
+                        api_key: 'test-api-key',
                     }),
                 },
             },
@@ -455,39 +463,41 @@ describe("TranscribeMedia", () => {
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {};
+        const params = {} satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
 
         await expect(testEnv.run(transcribeMedia, payload)).rejects.toThrow(
-            "No source found for object test-object-id"
+            'No source found for object test-object-id',
         );
     });
 
-    it("should handle Gladia 422 error", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
-        const { FetchClient, RequestError } = await import("@vertesia/api-fetch-client");
+    it('should handle Gladia 422 error', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
+        const { FetchClient, RequestError } = await import('@vertesia/api-fetch-client');
 
         // Create a mock Request object
-        const mockRequest = new Request("https://api.gladia.io/v2/transcription", {
-            method: "POST",
+        const mockRequest = new Request('https://api.gladia.io/v2/transcription', {
+            method: 'POST',
         });
 
         const mockFetchClient = {
             withHeaders: vi.fn().mockReturnThis(),
-            post: vi.fn().mockRejectedValue(
-                new RequestError("Invalid audio format", mockRequest, 422, { error: "Invalid audio format" })
-            ),
+            post: vi
+                .fn()
+                .mockRejectedValue(
+                    new RequestError('Invalid audio format', mockRequest, 422, { error: 'Invalid audio format' }),
+                ),
         };
-        vi.mocked(FetchClient).mockImplementation(function(this: any) {
-            return mockFetchClient as any;
+        vi.mocked(FetchClient).mockImplementation(function (this: unknown) {
+            return mockFetchClient as unknown;
         });
 
         const mockClient = {
@@ -495,65 +505,65 @@ describe("TranscribeMedia", () => {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
-                        url: "https://api.gladia.io/v2",
+                        api_key: 'test-api-key',
+                        url: 'https://api.gladia.io/v2',
                     }),
                 },
             },
             objects: {
                 retrieve: vi.fn().mockResolvedValue({
                     content: {
-                        source: "gs://test-bucket/audio.mp3",
+                        source: 'gs://test-bucket/audio.mp3',
                     },
                     text: null,
                 }),
             },
             files: {
                 getDownloadUrl: vi.fn().mockResolvedValue({
-                    url: "https://download.example.com/audio.mp3",
+                    url: 'https://download.example.com/audio.mp3',
                 }),
             },
             store: {
-                baseUrl: "http://mock-store",
+                baseUrl: 'http://mock-store',
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {};
+        const params = {} satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
         const result: TranscriptMediaResult = await testEnv.run(transcribeMedia, payload);
 
         expect(result).toMatchObject({
             hasText: false,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             status: TextExtractionStatus.error,
-            error: expect.stringContaining("Gladia transcription error"),
+            error: expect.stringContaining('Gladia transcription error'),
         });
     });
 
-    it("should handle missing download URL", async () => {
-        const { setupActivity } = await import("../../dsl/setup/ActivityContext.js");
+    it('should handle missing download URL', async () => {
+        const { setupActivity } = await import('../../dsl/setup/ActivityContext.js');
 
         const mockClient = {
             projects: {
                 integrations: {
                     retrieve: vi.fn().mockResolvedValue({
                         enabled: true,
-                        api_key: "test-api-key",
+                        api_key: 'test-api-key',
                     }),
                 },
             },
             objects: {
                 retrieve: vi.fn().mockResolvedValue({
                     content: {
-                        source: "gs://test-bucket/audio.mp3",
+                        source: 'gs://test-bucket/audio.mp3',
                     },
                     text: null,
                 }),
@@ -565,19 +575,17 @@ describe("TranscribeMedia", () => {
             },
         } as unknown as VertesiaClient;
 
-        const params: TranscriptMediaParams = {};
+        const params = {} satisfies TranscriptMediaParams;
 
         vi.mocked(setupActivity).mockResolvedValue({
             client: mockClient,
-            objectId: "test-object-id",
+            objectId: 'test-object-id',
             inputType: 'objectIds',
             params,
         } as unknown as ActivityContext<TranscriptMediaParams>);
 
-        const payload = createTestPayload(params, "test-object-id");
+        const payload = createTestPayload(params, 'test-object-id');
 
-        await expect(testEnv.run(transcribeMedia, payload)).rejects.toThrow(
-            "Error fetching media URL"
-        );
+        await expect(testEnv.run(transcribeMedia, payload)).rejects.toThrow('Error fetching media URL');
     });
 });