apps/web/public/language-sw.js-78-86 (1)

78-86: ⚠️ Potential issue | 🟡 Minor

Include video extensions in the static-asset skip list.

The new guard is intended to bypass language headers for static assets, but common video formats (now part of the product) are still processed. If same-origin videos are served from /public or /static, this will fragment caches and may complicate range requests. Consider extending the regex.

🔧 Suggested update

-    pathname.match(/\.(svg|png|jpg|jpeg|gif|webp|ico|css|js|woff|woff2|ttf|eot|map)$/i) ||
+    pathname.match(/\.(svg|png|jpg|jpeg|gif|webp|ico|css|js|woff|woff2|ttf|eot|map|mp4|webm|mov|m4v)$/i) ||

apps/web/src/components/sidebar.test.tsx-70-73 (1)

70-73: ⚠️ Potential issue | 🟡 Minor

Align the settings-page collapse assertion with the new lowercase branding.

The title now renders as lmring, but the settings-page test still checks for LMRing, which can pass even if the title is mistakenly visible. Update the assertion to match the new casing (or use a case-insensitive check).

🔧 Proposed test fix

-    expect(screen.queryByText('LMRing')).not.toBeInTheDocument();
+    expect(screen.queryByText('lmring')).not.toBeInTheDocument();

Also applies to: 208-214

apps/web/src/components/arena/video-player.tsx-45-46 (1)

45-46: ⚠️ Potential issue | 🟡 Minor

Check response status before processing blob.

response.blob() will proceed even on non-2xx responses (e.g., 403, 404), resulting in downloading an error page as a video file.

🛡️ Proposed fix to validate response

                 fetch(url)
-                  .then((response) => response.blob())
+                  .then((response) => {
+                    if (!response.ok) {
+                      throw new Error(`Download failed: ${response.status}`);
+                    }
+                    return response.blob();
+                  })

apps/web/src/components/arena/video-player.tsx-43-56 (1)

43-56: ⚠️ Potential issue | 🟡 Minor

Add error handling for the download fetch.

The download handler silently fails if the fetch request fails (network error, CORS, 404, etc.). Users won't know why the download didn't work.

🛡️ Proposed fix with error handling

             listeners: {
               download: (event: Event) => {
                 event.preventDefault();
                 fetch(url)
                   .then((response) => response.blob())
                   .then((blob) => {
                     const blobUrl = URL.createObjectURL(blob);
                     const a = document.createElement('a');
                     a.href = blobUrl;
                     a.download = 'video.mp4';
                     document.body.appendChild(a);
                     a.click();
                     document.body.removeChild(a);
                     URL.revokeObjectURL(blobUrl);
-                  });
+                  })
+                  .catch((error) => {
+                    console.error('Failed to download video:', error);
+                  });
               },
             },

apps/web/src/app/(landing)/page.tsx-56-63 (1)

56-63: ⚠️ Potential issue | 🟡 Minor

Add aria-hidden="true" to the decorative glow layer to prevent screen readers from announcing the tagline twice.

The duplicated {t('Index.tagline')} text renders in both the glow layer (line 58) and the main text layer (line 62). Since the glow layer is purely decorative (using absolute positioning and blur), it should be hidden from assistive technology.

🔧 Suggested change

-                <span className="absolute inset-0 bg-gradient-to-r from-indigo-500 via-blue-500 to-indigo-500 bg-clip-text text-transparent opacity-70 blur-sm">
+                <span
+                  aria-hidden="true"
+                  className="absolute inset-0 bg-gradient-to-r from-indigo-500 via-blue-500 to-indigo-500 bg-clip-text text-transparent opacity-70 blur-sm"
+                >
                   {t('Index.tagline')}
                 </span>

apps/web/src/components/arena/chat/video-attachment.tsx-30-31 (1)

30-31: ⚠️ Potential issue | 🟡 Minor

Localize the “Generating video…” label.
This is user-facing text; please move it to the i18n dictionary and add keys for en/fr/zh.

As per coding guidelines: Translate all three locale files (en, fr, zh) when adding new i18n keys during development.

apps/web/src/app/api/workflow/video-stream/route.ts-114-125 (1)

114-125: ⚠️ Potential issue | 🟡 Minor

Use provider mimeType for upload content type and filename.
Hardcoding video/mp4 and the .mp4 extension can mislabel webm/other outputs and break playback or caching.

🛠️ Suggested fix

-                  const storage = createStorageService();
-                  const timestamp = Date.now();
-                  const randomId = crypto.randomUUID().slice(0, 8);
-                  storagePath = `users/${session.user.id}/videos/${timestamp}-${randomId}.mp4`;
+                  const storage = createStorageService();
+                  const timestamp = Date.now();
+                  const randomId = crypto.randomUUID().slice(0, 8);
+                  const mimeType = event.video.mimeType ?? 'video/mp4';
+                  const extension =
+                    mimeType.split('/')[1]?.split(';')[0]?.trim() || 'mp4';
+                  storagePath = `users/${session.user.id}/videos/${timestamp}-${randomId}.${extension}`;

-                  await storage.upload(storagePath, videoBuffer, {
-                    contentType: 'video/mp4',
-                  });
+                  await storage.upload(storagePath, videoBuffer, {
+                    contentType: mimeType,
+                  });

apps/web/src/app/api/workflow/video-stream/route.ts-30-30 (1)

30-30: ⚠️ Potential issue | 🟡 Minor

Add an explicit return type for the POST handler.

♻️ Suggested refactor

-export async function POST(request: Request) {
+export async function POST(request: Request): Promise<Response> {

Async Next.js API route handlers should explicitly declare their return type as Promise<Response> to comply with TypeScript best practices and coding guidelines.

apps/web/src/stores/workflow-store.tsx-556-581 (1)

556-581: ⚠️ Potential issue | 🟡 Minor

Potential state inconsistency when stopping video generation.

When setVideoGenerating(id, false) is called, pendingResponse is cleared but status is preserved via workflow.status (line 572). If the workflow was in 'running' state, it remains 'running' even though there's no pending response. This could leave the workflow in an inconsistent state.

Consider explicitly setting the status when stopping video generation, similar to how completePendingResponse sets status: 'completed'.

🔧 Proposed fix

         setVideoGenerating: (id, isGenerating) => {
           set(
             (state) => {
               const workflow = state.workflows.get(id);
               if (!workflow) return state;
 
               const newMap = new Map(state.workflows);
               newMap.set(id, {
                 ...workflow,
                 pendingResponse: isGenerating
                   ? {
                       content: '',
                       startTime: Date.now(),
                       isVideoGenerating: true,
                     }
                   : undefined,
-                status: isGenerating ? 'running' : workflow.status,
+                status: isGenerating ? 'running' : 'pending',
                 error: isGenerating ? undefined : workflow.error,
                 updatedAt: new Date(),
               });
               return { workflows: newMap };
             },

packages/video-runtime/src/providers/base.ts-108-142 (1)

108-142: ⚠️ Potential issue | 🟡 Minor

Reject non-positive durations to avoid invalid requests.

params.duration is only checked when greater than the max; 0 or negative durations pass validation and can trigger provider errors. Add an explicit validation for <= 0.

🛡️ Suggested validation

-    if (params.duration && params.duration > this.capabilities.maxDurationSeconds) {
+    if (params.duration !== undefined && params.duration <= 0) {
+      errors.push('Duration must be greater than 0 seconds');
+    }
+    if (params.duration !== undefined && params.duration > this.capabilities.maxDurationSeconds) {
       errors.push(
         `Duration ${params.duration}s exceeds maximum ${this.capabilities.maxDurationSeconds}s`,
       );
     }

packages/video-runtime/src/utils/http.ts-90-106 (1)

90-106: ⚠️ Potential issue | 🟡 Minor

Avoid JSON-stringifying non-JSON request bodies.

httpRequest always JSON.stringifys any provided body, which breaks if callers pass a string, FormData, or other BodyInit types. This also forces Content-Type: application/json even for non-JSON requests.

🐛 Safer body handling

-  const requestHeaders: Record<string, string> = {
-    'Content-Type': 'application/json',
-    Accept: 'application/json',
-    ...headers,
-  };
+  const isJsonBody =
+    body !== undefined &&
+    typeof body === 'object' &&
+    !(body instanceof FormData) &&
+    !(body instanceof URLSearchParams);
+
+  const requestHeaders: Record<string, string> = {
+    ...(isJsonBody ? { 'Content-Type': 'application/json' } : {}),
+    Accept: 'application/json',
+    ...headers,
+  };
...
-      body: body !== undefined ? JSON.stringify(body) : undefined,
+      body: body === undefined ? undefined : isJsonBody ? JSON.stringify(body) : (body as BodyInit),

packages/video-runtime/src/providers/google.ts-209-233 (1)

209-233: ⚠️ Potential issue | 🟡 Minor

Handle synchronous completion without dropping the video result.

If Google ever returns a synchronous done response, you return "sync-completed" but never preserve the actual video payload—pollTaskStatus then yields completed with result: undefined. That can surface as “success with no video”.

💡 One possible fix (stash the sync result)

 export class GoogleVideoProvider extends BaseVideoProvider {
+  private syncResult?: VideoGenerationResult;
   ...

   protected async createTask(...) {
     ...
     if (!response.data.name) {
       if (response.data.done && response.data.response) {
-        return 'sync-completed';
+        this.syncResult = extractVideoResult(response.data);
+        return 'sync-completed';
       }
       throw VideoError.providerError(...);
     }
     return response.data.name;
   }

   protected async pollTaskStatus(...) {
     if (taskId === 'sync-completed') {
       return {
         taskId,
-        status: 'completed',
-        result: undefined,
+        status: this.syncResult ? 'completed' : 'failed',
+        result: this.syncResult,
       };
     }
     ...
   }
 }

packages/ai-hub/src/types/runtime.ts (1)

115-118: Consider adding a progress event variant for video generation feedback.

The PR objectives mention "SSE-based video streaming workflow API for progress updates," but the current union only includes heartbeat, video, and error variants. Since video generation can be a long-running operation, a progress event would improve the user experience by providing feedback during generation.

💡 Suggested enhancement

 export type VideoStreamEvent =
   | { type: 'heartbeat' }
+  | { type: 'progress'; progress: number; message?: string }
   | { type: 'video'; video: VideoGenerationResult }
   | { type: 'error'; error: string };

apps/web/src/app/api/conversations/[id]/full/route.ts (1)

9-26: Consider extracting attachmentsWithUrls to a shared utility.

This function is duplicated verbatim in apps/web/src/app/api/model-responses/route.ts. To adhere to DRY principles and simplify maintenance, consider extracting it to a shared location (e.g., @/libs/attachments or within @lmring/storage).

♻️ Example shared utility

Create a new file apps/web/src/libs/attachments.ts:

import type { ResponseAttachment } from '@lmring/database/schema';
import { createStorageService } from '@lmring/storage';

/**
 * Convert attachment storage keys to signed URLs
 * If an attachment already has an external URL (e.g., video URLs), use that directly
 */
export async function attachmentsWithUrls(
  attachments: ResponseAttachment[] | null,
): Promise<Array<ResponseAttachment & { url: string }> | null> {
  if (!attachments || attachments.length === 0) return null;

  const storage = createStorageService();

  return Promise.all(
    attachments.map(async (att) => ({
      ...att,
      url: att.url || (await storage.createDownloadUrl(att.key)),
    })),
  );
}

Then import from both route files:

import { attachmentsWithUrls } from '@/libs/attachments';

apps/web/src/app/layout.tsx (1)

21-23: Use an interface and explicit return type for RootLayout.

Inline object types and implicit async return types violate TS style guidance for this repo. Consider:

♻️ Suggested refactor

+interface RootLayoutProps {
+  children: React.ReactNode;
+}
+
-export default async function RootLayout(props: { children: React.ReactNode }) {
+export default async function RootLayout(
+  props: RootLayoutProps
+): Promise<React.ReactElement> {

As per coding guidelines, Prefer interfaces over types for object shapes in TypeScript; Use explicit return types for functions in TypeScript.

apps/web/src/components/arena/vote-bar.test.tsx (1)

54-57: Consider adding explicit disabled={false} to clarify test intent.

The test verifies that VoteBar renders nothing, but doesn't explicitly pass disabled={false}. Since the implementation unconditionally returns null (regardless of the disabled prop), consider making this explicit in the test to document that voting is disabled at the implementation level, not via props.

  it('should render nothing when voting is disabled', () => {
-   const { container } = render(<VoteBar {...defaultProps} />);
+   const { container } = render(<VoteBar {...defaultProps} disabled={false} />);
    expect(container.firstChild).toBeNull();
  });

apps/web/src/components/arena/vote-bar.tsx (3)

27-35: Add explicit return type for VoteBar component.

The component lacks an explicit return type annotation. As per coding guidelines, TypeScript functions should have explicit return types.

+// VOTE_DISABLED: VoteBar component temporarily disabled
 export const VoteBar = React.memo(function VoteBar({
   messageId: _messageId,
   modelResponses: _modelResponses,
   comparisonType: _comparisonType,
   disabled: _disabled = false,
-}: VoteBarProps) {
+}: VoteBarProps): React.ReactNode {
   // Return null to hide the vote bar while voting is disabled
   return null;

---

37-192: Consider extracting commented implementation to a separate branch or using feature flags.

The large block of commented-out code (150+ lines) increases maintenance burden and risks becoming stale. Consider:

1. Keeping the original implementation in a separate git branch for reference
2. Using a feature flag/environment variable to toggle voting at runtime
3. If this is truly temporary, adding a TODO with a target date/issue reference for re-enablement

This would keep the codebase cleaner while preserving the ability to restore functionality.

---

195-208: Add explicit return type for useCardVoting hook.

The hook lacks an explicit return type annotation.

+interface CardVotingHandlers {
+  handleCardClick: (modelResponseId: string) => Promise<void>;
+  handleCardHover: (modelResponseId: string) => void;
+  handleCardHoverLeave: () => void;
+  isVoted: boolean;
+  isSubmitting: boolean;
+}
+
 // VOTE_DISABLED: useCardVoting hook temporarily disabled
 export function useCardVoting(
   _messageId: string,
   _comparisonType: ComparisonType,
   _participantIds: string[],
-) {
+): CardVotingHandlers {
   // Return no-op handlers while voting is disabled
   return {

apps/web/src/components/arena/model-card.tsx (1)

135-147: Consider removing or commenting out unused vote state computations.

effectiveVoteState is computed but only used to look up empty strings from voteStateBorderStyles. This computation could be removed along with the border styles object while voting is disabled:

-  const effectiveVoteState = hoverState || voteState;
-
-  // VOTE_DISABLED: Vote state border styles temporarily disabled
-  const voteStateBorderStyles: Record<string, string> = {
-    // winner: 'ring-1 ring-amber-500 border-amber-500 shadow-amber-500/20',
-    winner: '',
-    loser: '',
-    // tie: 'ring-1 ring-green-500 border-green-500 shadow-green-500/20',
-    tie: '',
-    // all_bad: 'ring-1 ring-red-500 border-red-500 shadow-red-500/20',
-    all_bad: '',
-    none: '',
-  };
+  // VOTE_DISABLED: Vote state border styles temporarily disabled
+  // const effectiveVoteState = hoverState || voteState;
+  // const voteStateBorderStyles: Record<string, string> = {
+  //   winner: 'ring-1 ring-amber-500 border-amber-500 shadow-amber-500/20',
+  //   loser: '',
+  //   tie: 'ring-1 ring-green-500 border-green-500 shadow-green-500/20',
+  //   all_bad: 'ring-1 ring-red-500 border-red-500 shadow-red-500/20',
+  //   none: '',
+  // };

And update cardClasses to remove the lookup:

   const cardClasses = cn(
     'h-full min-h-0 arena-card flex flex-col glass-effect relative overflow-hidden transition-all duration-200',
-    voteStateBorderStyles[effectiveVoteState],
     // VOTE_DISABLED: Vote hover styles temporarily disabled
     // isVotable && voteState === 'none' && 'cursor-pointer hover:ring-1 hover:ring-amber-500/50',
   );

apps/web/src/components/arena/video-player.tsx (1)

17-17: Add explicit return type to the component function.

Per coding guidelines, functions should have explicit return types. Consider adding React.JSX.Element or JSX.Element as the return type.

-export function VideoPlayer({ url, thumbnailUrl, className }: VideoPlayerProps) {
+export function VideoPlayer({ url, thumbnailUrl, className }: VideoPlayerProps): React.JSX.Element {

apps/web/src/libs/video-workflow-api.ts (1)

73-102: Consider flushing the TextDecoder after the read loop.

When done is true, there may be remaining bytes in the decoder's internal buffer that need to be flushed. Additionally, any remaining content in buffer after the loop should be processed.

♻️ Suggested improvement

   try {
     while (true) {
       const { done, value } = await reader.read();

       if (done) {
+        // Flush decoder and process any remaining buffer
+        buffer += decoder.decode();
+        if (buffer.trim() && buffer.startsWith('data: ')) {
+          const data = buffer.slice(6).trim();
+          if (data && data !== '[DONE]') {
+            try {
+              const event = JSON.parse(data) as WorkflowStreamEvent;
+              yield event;
+            } catch {
+              console.error('Failed to parse final SSE event:', data);
+            }
+          }
+        }
         break;
       }

       buffer += decoder.decode(value, { stream: true });

apps/web/src/components/landing/animated-hero.tsx (1)

7-13: Consider using interface for props definition.

As per coding guidelines, prefer interfaces over types for object shapes in TypeScript. This is a minor style consideration.

♻️ Suggested change

-type AnimatedHeroProps = {
+interface AnimatedHeroProps {
   title: ReactNode;
   description: ReactNode;
   actions: ReactNode;
   badge?: ReactNode;
   logo?: ReactNode;
-};
+}

packages/video-runtime/src/utils/errors.ts (2)

51-92: Consider case-insensitive matching for error message patterns.

The string matching uses a mix of lowercase patterns ('timeout', 'network') and uppercase ('ETIMEDOUT', 'ECONNREFUSED'). Consider normalizing to case-insensitive checks for more robust error classification.

♻️ Suggested improvement

     if (error instanceof Error) {
       // Check for common HTTP error patterns
-      const message = error.message;
+      const message = error.message.toLowerCase();

-      if (message.includes('timeout') || message.includes('ETIMEDOUT')) {
+      if (message.includes('timeout') || message.includes('etimedout')) {
         return new VideoError({
           code: 'TIMEOUT',
-          message: `Request timeout: ${message}`,
+          message: `Request timeout: ${error.message}`,
           retryable: true,
           cause: error,
           ...defaults,
         });
       }

-      if (message.includes('network') || message.includes('ECONNREFUSED')) {
+      if (message.includes('network') || message.includes('econnrefused')) {
         return new VideoError({
           code: 'NETWORK_ERROR',
-          message: `Network error: ${message}`,
+          message: `Network error: ${error.message}`,
           retryable: true,
           cause: error,
           ...defaults,
         });
       }

---

224-229: Consider extending retryability check for non-VideoError instances.

The current implementation returns false for any non-VideoError. Consider checking for common retryable patterns in standard errors (e.g., network errors, timeouts) to make the utility more broadly useful.

♻️ Alternative approach

 export function isRetryableError(error: unknown): boolean {
   if (error instanceof VideoError) {
     return error.retryable;
   }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    return (
+      message.includes('timeout') ||
+      message.includes('etimedout') ||
+      message.includes('econnrefused') ||
+      message.includes('rate limit') ||
+      message.includes('429')
+    );
+  }
   return false;
 }

packages/video-runtime/src/utils/validation.ts (2)

70-82: Tie the schema type to VideoGenerationParams to avoid unsafe casts.
Casting in parseParams can mask drift between the Zod schema and the TS type.

🔧 Suggested change

-export const VideoGenerationParamsSchema = z.object({
+export const VideoGenerationParamsSchema: z.ZodType<VideoGenerationParams> = z.object({
   model: z.string().min(1, 'Model is required'),
   input: VideoGenerationInputSchema,
   width: z.number().int().positive().optional(),
   height: z.number().int().positive().optional(),
   aspectRatio: VideoAspectRatioSchema.optional(),
   duration: z.number().positive().max(300).optional(),
   fps: z.number().int().positive().max(120).optional(),
   quality: VideoQualitySchema.optional(),
   audio: z.boolean().optional(),
   seed: z.number().int().nonnegative().optional(),
   providerOptions: z.record(z.string(), z.unknown()).optional(),
 });
@@
 export function parseParams(params: unknown): VideoGenerationParams {
-  return VideoGenerationParamsSchema.parse(params) as VideoGenerationParams;
+  return VideoGenerationParamsSchema.parse(params);
 }

Also applies to: 116-118

---

123-125: Use the shared TextToVideoInput interface for the type guard.
This keeps the predicate aligned with the canonical input type.

🔧 Suggested change

-import type { ImageToVideoInput, ValidationResult, VideoGenerationParams } from '../types';
+import type { ImageToVideoInput, TextToVideoInput, ValidationResult, VideoGenerationParams } from '../types';
@@
 export function isTextToVideoInput(
   input: VideoGenerationParams['input'],
-): input is { type: 'text-to-video'; prompt: string; negativePrompt?: string } {
+): input is TextToVideoInput {
   return input.type === 'text-to-video';
 }

As per coding guidelines: Prefer interfaces over types for object shapes in TypeScript.

apps/web/src/app/(landing)/page.test.tsx (1)

7-13: Prefer vi.spyOn for these mocks.
This aligns with the testing guideline and keeps module shapes intact.

🔧 Example refactor

-import { describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as i18n from '@lmring/i18n';
+import * as serverTranslations from '@/libs/server-translations';
@@
-vi.mock('@lmring/i18n', () => ({
-  isValidLocale: (locale: string) => locale === 'en' || locale === 'fr',
-}));
-
-vi.mock('@/libs/server-translations', () => ({
-  getServerTranslations: async (locale: string) => (key: string) => `${locale}:${key}`,
-}));
+beforeEach(() => {
+  vi.spyOn(i18n, 'isValidLocale').mockImplementation(
+    (locale: string) => locale === 'en' || locale === 'fr',
+  );
+  vi.spyOn(serverTranslations, 'getServerTranslations').mockResolvedValue(
+    (key: string) => `en:${key}`,
+  );
+});

As per coding guidelines: Prefer vi.spyOn over vi.mock in test files.

apps/web/src/components/arena/chat/chat-list.tsx (1)

19-28: Add an explicit return type for the component.

🔧 Suggested change

-export function ChatList({
+export function ChatList({
   messages,
   pendingResponse,
   isLoading,
   status,
   error,
   providerId,
   onRetry,
   onMaximize,
-}: ChatListProps) {
+}: ChatListProps): JSX.Element {

As per coding guidelines: Use explicit return types for functions in TypeScript.

apps/web/src/components/arena/arena-hero-section.tsx (1)

27-27: Add an explicit return type for the component.

🔧 Suggested change

-export function ArenaHeroSection() {
+export function ArenaHeroSection(): JSX.Element {

As per coding guidelines: Use explicit return types for functions in TypeScript.

apps/web/src/app/(landing)/page.tsx (2)

17-19: Prefer an interface for IIndexProps.

🔧 Suggested change

-type IIndexProps = {
+interface IIndexProps {
   params: Promise<{ locale: string }>;
-};
+}

As per coding guidelines: Prefer interfaces over types for object shapes in TypeScript.

---

32-35: Add an explicit return type for the page component.

🔧 Suggested change

-export default async function Index(props: IIndexProps) {
+export default async function Index(props: IIndexProps): Promise<JSX.Element> {

As per coding guidelines: Use explicit return types for functions in TypeScript.

apps/web/src/components/arena/chat/video-attachment.tsx (1)

13-22: Add explicit return types to the exported components.

♻️ Suggested refactor

-export function VideoAttachmentDisplay({ data, className }: VideoAttachmentProps) {
+export function VideoAttachmentDisplay({
+  data,
+  className,
+}: VideoAttachmentProps): JSX.Element {
   return (
     <div className={cn('w-[480px] rounded-lg border bg-muted', className)}>
       <VideoPlayer url={data.url} thumbnailUrl={data.thumbnailUrl} className="w-full" />
     </div>
   );
 }

-export function VideoGeneratingIndicator({ className }: { className?: string }) {
+export function VideoGeneratingIndicator({
+  className,
+}: {
+  className?: string;
+}): JSX.Element {
   return (
     <div
       className={cn(
         'flex items-center gap-2 p-4 rounded-lg border bg-muted/30 w-[350px]',
         className,
       )}
     >

Both VideoAttachmentDisplay and VideoGeneratingIndicator lack explicit return types. Per TypeScript best practices and project guidelines, add : JSX.Element to both functions.

packages/model-depot/src/models/togetherai.ts (1)

323-342: Consider adding maxDurationSeconds for consistency.

The Wan-AI models (Wan2.2-I2V-A14B and Wan2.2-T2V-A14B) are missing maxDurationSeconds, resolutions, and fps properties that other video models in this file have. If these values are known, adding them would improve consistency and enable better validation in the video runtime.

💡 Example for consistency

   {
     id: 'Wan-AI/Wan2.2-I2V-A14B',
     displayName: 'Wan 2.2 Image-to-Video',
     description: 'Wan-AI image-to-video generation model',
     type: 'video',
     enabled: false,
     abilities: { videoOutput: true },
+    maxDurationSeconds: 5,
+    resolutions: ['1280x720', '720x1280'],
+    fps: 24,
     organization: 'Wan-AI',
     runtimeProvider: 'openai-compatible',
   },

packages/video-runtime/src/providers/kling.ts (1)

144-154: Minor: Simplify model resolution logic.

The resolveModelId method has redundant branches. The final return stripped at line 153 handles the startsWith('kling-') case already.

♻️ Simplified version

   resolveModelId(modelId: string): string {
     const stripped = stripProviderPrefix(modelId);
     // Map common names to Kling model IDs
     if (stripped === 'kling' || stripped === 'kling-v2') {
       return 'kling-v2-master';
     }
-    if (stripped.startsWith('kling-')) {
-      return stripped;
-    }
     return stripped;
   }

packages/ai-hub/src/core/video/index.ts (1)

61-71: Redundant regex pattern in isOfficialGoogleEndpoint.

The second pattern /^https:\/\/.*\.googleapis\.com/ is a superset of the first pattern /^https:\/\/generativelanguage\.googleapis\.com/, making the first pattern redundant. Consider simplifying or documenting the intent if the specificity is deliberate.

♻️ Suggested simplification

   const officialPatterns = [
-    /^https:\/\/generativelanguage\.googleapis\.com/,
     /^https:\/\/.*\.googleapis\.com/,
     /^https:\/\/aiplatform\.googleapis\.com/,
   ];

packages/model-depot/src/types/model.ts (1)

127-135: Consider adding video-specific fields to FullModelCard for completeness.

FullModelCard serves as a unified type but lacks video-specific fields like maxDurationSeconds and fps that exist in VideoModelCard. This could lead to data loss when converting from VideoModelCard to FullModelCard.

♻️ Proposed addition to FullModelCard

 export interface FullModelCard extends BaseModelCard {
   type: AiModelType;
   abilities?: ModelAbilities;
   pricing?: ModelPricing;
   maxDimension?: number;
   resolutions?: string[];
+  maxDurationSeconds?: number;
+  fps?: number;
   runtimeProvider?: string;
   runtimeModelId?: string;
 }

packages/video-runtime/src/core/factory.ts (1)

84-103: DRY the supported-provider list to prevent drift.

isSupported and getSupportedProviders each define their own list. A shared constant avoids inconsistencies when providers are added/removed.

♻️ Suggested refactor

+const SUPPORTED_PROVIDERS: VideoRuntimeProvider[] = [
+  'openai',
+  'minimax',
+  'google',
+  'kling',
+  'seedance',
+  'vidu',
+  'openai-compatible',
+];
+
   isSupported(provider: VideoRuntimeProvider): boolean {
-    const supportedProviders: VideoRuntimeProvider[] = [
-      'openai',
-      'minimax',
-      'google',
-      'kling',
-      'seedance',
-      'vidu',
-      'openai-compatible',
-    ];
-    return supportedProviders.includes(provider);
+    return SUPPORTED_PROVIDERS.includes(provider);
   }

   getSupportedProviders(): VideoRuntimeProvider[] {
-    return ['openai', 'minimax', 'google', 'kling', 'seedance', 'vidu', 'openai-compatible'];
+    return [...SUPPORTED_PROVIDERS];
   }

packages/video-runtime/src/providers/openai-compatible.ts (1)

53-72: Align response typing with actual data shapes.

extractVideoUrl handles both array and object forms, but OpenAICompatibleVideoResponse.data only models an array, forcing casts. A union keeps type safety.

♻️ Suggested typing update

 interface OpenAICompatibleVideoResponse {
   id?: string; // OpenAI standard format
   task_id?: string; // MiniMax/bltcy.ai format
   request_id?: string; // Alternative format
   status: string;
   model?: string;
   created_at?: number;
   video_url?: string;
   url?: string;
   output?: string; // Veo API format: direct output field
-  data?: Array<{
-    url: string;
-    revised_prompt?: string;
-  }>;
+  data?:
+    | Array<{
+        url: string;
+        revised_prompt?: string;
+      }>
+    | { output?: string };
   error?: {
     code: string;
     message: string;
   };
   progress?: number;
 }

packages/video-runtime/src/providers/openai.ts (1)

79-105: Align aspectRatioToSize mappings with declared capabilities.

aspectRatioToSize includes 21:9, but capabilities.aspectRatios doesn't, so validation blocks it. Either add 21:9 to capabilities or drop the mapping to avoid dead code.

♻️ Option: remove unsupported mapping

     case '3:4':
       return '1080x1440';
-    case '21:9':
-      return '2560x1080';
     default:
       return undefined;

apps/web/src/hooks/use-workflow-execution.ts (1)

439-597: Add explicit Promise return types to new callbacks.

The new async callbacks don’t declare return types. Please annotate them to match the TypeScript guideline.

✍️ Suggested annotations

-  const executeVideoWorkflowStream = useCallback(
-    async (
+  const executeVideoWorkflowStream = useCallback(
+    async (
       workflow: ArenaWorkflow,
       prompt: string,
       options?: {
         isNewConversation?: boolean;
         existingDbMessageId?: string;
       },
-    ) => {
+    ): Promise<void> => {
       ...
     },
     [...]
   );

-  const startAllSyncedVideoWorkflows = useCallback(async () => {
+  const startAllSyncedVideoWorkflows = useCallback(async (): Promise<void> => {
     ...
   }, [...]);

As per coding guidelines, Use explicit return types for functions in TypeScript.

apps/web/src/app/(auth)/arena/[[...conversationId]]/page.tsx (1)

1046-1169: Add an explicit return type to handleSubmit.

The modified callback lacks a return type; per the TS guideline, consider annotating it as Promise<void>.

As per coding guidelines, Use explicit return types for functions in TypeScript.