Add Kiro CLI integration for v4 API

- Add api_core/kiro.py with CLI-based translation
- Add v4 router with Kiro endpoints (/v4/GPU, /v4/NPU)
- Update app.py to include v4 routers
- Clean ANSI formatting from CLI output
- Maintain same API structure as v3 Gemini integration

Author: Defeeeee

api_core/app.py

@@ -26,12 +26,13 @@ async def global_exception_handler(request: Request, exc: Exception):
         )
 
     # Dynamically load routers from versioned packages
-    from .routers import v1, v2, v3
+    from .routers import v1, v2, v3, v4
 
     versions = {
         "v1": v1,
         "v2": v2,
-        "v3": v3
+        "v3": v3,
+        "v4": v4
     }
 
     for version_name, version_package in versions.items():

api_core/kiro.py

@@ -0,0 +1,90 @@
+import asyncio
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+def clean_kiro_output(text: str) -> str:
+    """Clean ANSI escape codes and CLI formatting from Kiro output."""
+    if not text:
+        return text
+    
+    # Remove ANSI escape codes
+    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+    cleaned = ansi_escape.sub('', text)
+    
+    # Remove CLI prompt markers
+    cleaned = re.sub(r'^>\s*', '', cleaned, flags=re.MULTILINE)
+    
+    return cleaned.strip()
+
+async def call_kiro_cli(prompt: str):
+    """Calls Kiro using CLI interface."""
+    try:
+        # Run kiro-cli chat command with prompt as argument
+        process = await asyncio.create_subprocess_exec(
+            'kiro-cli', 'chat', '--no-interactive', prompt,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        
+        stdout, stderr = await process.communicate()
+        
+        if process.returncode == 0:
+            raw_output = stdout.decode().strip()
+            return clean_kiro_output(raw_output)
+        else:
+            logger.error(f"Kiro CLI error: {stderr.decode()}")
+            return None
+            
+    except Exception as e:
+        logger.error(f"Error calling Kiro CLI: {e}")
+        return None
+
+async def glosses_to_text_async(glosses, target_language="English"):
+    """Translate DGS glosses to text using Kiro CLI."""
+    if target_language == "German":
+        prompt = f"""Translate these German Sign Language glosses to German: {glosses}
+
+Return only the German translation, no explanations."""
+    else:
+        prompt = f"""Translate these German Sign Language glosses to English: {glosses}
+
+Return only the English translation, no explanations."""
+
+    response = await call_kiro_cli(prompt)
+    return response
+
+async def custom_prompt_async(prompt):
+    """Send custom prompt to Kiro CLI."""
+    response = await call_kiro_cli(prompt)
+    return response
+
+async def process_video_translation(prediction_text: str, target_language: str = "English"):
+    """
+    High-level function to process the translation flow using Kiro CLI:
+    1. Translate glosses to text
+    2. Generate summary (if English)
+    3. Return result dict
+    """
+    if not prediction_text:
+        return None
+
+    kiro_response = await glosses_to_text_async(prediction_text, target_language)
+    
+    if not kiro_response:
+        return None
+
+    result = {"translation": kiro_response}
+
+    # Only generate summary for English
+    if target_language == "English":
+        summary_prompt = f"Summarize in 2-4 words: {kiro_response}"
+        kiro_summary = await custom_prompt_async(summary_prompt)
+        
+        if kiro_summary:
+            result["summary"] = kiro_summary
+        else:
+            result["summary"] = "No summary generated"
+
+    return result

api_core/routers/__init__.py

@@ -0,0 +1 @@
+from . import v4

api_core/routers/v4/README.md

@@ -0,0 +1,62 @@
+# SignAI-SFS v4 API with Kiro CLI Integration
+
+This version integrates Kiro AI via CLI for sign language translation.
+
+## Setup
+
+1. Install Kiro CLI:
+```bash
+# Download and install from https://kiro.dev
+curl -fsSL https://kiro.dev/install.sh | sh
+```
+
+2. Authenticate with Kiro:
+```bash
+kiro-cli auth login
+# Choose: GitHub, Google, AWS Builder ID, or AWS IAM Identity Center
+```
+
+3. Verify installation:
+```bash
+kiro-cli --version
+```
+
+## Endpoints
+
+### GPU Prediction with Kiro Translation
+```
+GET /v4/GPU?video_url=https://example.com/video.mp4
+```
+
+### NPU Prediction with Kiro Translation  
+```
+GET /v4/NPU?video_url=https://example.com/video.mp4
+```
+
+### Raw Prediction (no translation)
+```
+GET /v4/GPU/predict?video_url=https://example.com/video.mp4
+```
+
+## Response Format
+
+Translation endpoints return:
+```json
+{
+  "translation": "Translated text from Kiro",
+  "summary": "Brief summary" 
+}
+```
+
+Raw prediction endpoints return:
+```json
+{
+  "prediction": "Raw glosses from model"
+}
+```
+
+## Requirements
+
+- Kiro CLI must be installed and authenticated
+- Server must have access to run `kiro-cli` commands
+- Authenticated Kiro session (GitHub/Google/AWS Builder ID/IAM Identity Center)

api_core/routers/v4/__init__.py

@@ -0,0 +1,98 @@
+from fastapi import APIRouter, Query, HTTPException
+from fastapi.responses import JSONResponse
+import aiohttp
+import logging
+from api_core.kiro import process_video_translation
+from api_core.schemas import PredictionResponse, TranslationResponse, ErrorResponse
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Remote prediction endpoints
+REMOTE_API_URL = "http://100.71.0.60:8082"
+REMOTE_2_API_URL = "http://100.102.136.67:8082"
+
+@router.get("/GPU/predict", response_model=PredictionResponse, responses={500: {"model": ErrorResponse}})
+async def remote_predict(video_url: str = Query(..., description="URL of the video to predict")):
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{REMOTE_API_URL}/predict", params={"video_url": video_url}) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    return PredictionResponse(**data)
+                else:
+                    error_text = await response.text()
+                    logger.error(f"Remote API error: {response.status} - {error_text}")
+                    raise HTTPException(status_code=response.status, detail=f"Remote API error: {response.status}")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Remote prediction error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/GPU", response_model=TranslationResponse, responses={400: {"model": ErrorResponse}, 500: {"model": ErrorResponse}})
+async def remote_predict_kiro(video_url: str = Query(..., description="URL of the video to predict")):
+    try:
+        # 1. Get prediction from remote API
+        prediction_text = ""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{REMOTE_API_URL}/predict", params={"video_url": video_url}) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    prediction_text = data.get("prediction", "")
+                else:
+                    error_text = await response.text()
+                    logger.error(f"Remote API error: {response.status} - {error_text}")
+                    raise HTTPException(status_code=response.status, detail=f"Remote API error: {response.status}")
+        
+        if not prediction_text:
+            raise HTTPException(status_code=400, detail="No prediction received from remote API")
+
+        logger.info(f"Remote model made prediction: {prediction_text}. This will be sent to Kiro API for translation.")
+
+        result = await process_video_translation(prediction_text)
+        
+        if result:
+            return TranslationResponse(**result)
+        else:
+            raise HTTPException(status_code=500, detail="Failed to get translation from Kiro API")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Remote prediction error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/NPU", response_model=TranslationResponse, responses={400: {"model": ErrorResponse}, 500: {"model": ErrorResponse}})
+async def remote_predict_kiro2(video_url: str = Query(..., description="URL of the video to predict")):
+    try:
+        # 1. Get prediction from remote API
+        prediction_text = ""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{REMOTE_2_API_URL}/predict", params={"video_url": video_url}) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    prediction_text = data.get("prediction", "")
+                else:
+                    error_text = await response.text()
+                    logger.error(f"Remote API error: {response.status} - {error_text}")
+                    raise HTTPException(status_code=response.status, detail=f"Remote API error: {response.status}")
+
+        if not prediction_text:
+            raise HTTPException(status_code=400, detail="No prediction received from remote API")
+
+        logger.info(f"Remote model made prediction: {prediction_text}. This will be sent to Kiro API for translation.")
+
+        result = await process_video_translation(prediction_text)
+        
+        if result:
+            return TranslationResponse(**result)
+        else:
+            raise HTTPException(status_code=500, detail="Failed to get translation from Kiro API")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Remote prediction error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))