fix: resolve Gemini 404, directory collision, and Unicode decoding errors (#314)

- Fix Gemini 404 by preventing malformed api_base and global state pollution in LiteLLMVLMProvider.
- Fix AGFSClientError by adding exist_ok=True to mkdir calls in multiple parsers.
- Fix UnicodeDecodeError in VikingFS by implementing robust multi-stage decoding (UTF-8, GBK, Latin-1).

Author: honjiaxuan

openviking/models/vlm/backends/litellm_vlm.py

@@ -46,7 +46,7 @@
         "litellm_prefix": "deepseek",
     },
     "gemini": {
-        "keywords": ("gemini",),
+        "keywords": ("gemini", "google"),
         "env_key": "GEMINI_API_KEY",
         "litellm_prefix": "gemini",
     },
@@ -105,23 +105,24 @@ def __init__(self, config: Dict[str, Any]):
         if self.api_key:
             self._setup_env(self.api_key, self.model)
 
-        if self.api_base:
-            litellm.api_base = self.api_base
-
+        # Configure LiteLLM behavior (these are global but safe to re-set)
         litellm.suppress_debug_info = True
         litellm.drop_params = True
 
     def _setup_env(self, api_key: str, model: str | None) -> None:
         """Set environment variables based on detected provider."""
         provider = self._provider_name
-        if not provider and model:
-            provider = detect_provider_by_model(model)
+        if (not provider or provider == "litellm") and model:
+            detected = detect_provider_by_model(model)
+            if detected:
+                provider = detected
 
         if provider and provider in PROVIDER_CONFIGS:
             env_key = PROVIDER_CONFIGS[provider]["env_key"]
             os.environ[env_key] = api_key
             self._detected_provider = provider
         else:
+            # Fallback to OpenAI if provider is unknown or literal litellm
             os.environ["OPENAI_API_KEY"] = api_key
 
     def _resolve_model(self, model: str) -> str:
@@ -202,7 +203,14 @@ def _build_kwargs(self, model: str, messages: list) -> dict[str, Any]:
         if self.api_key:
             kwargs["api_key"] = self.api_key
         if self.api_base:
-            kwargs["api_base"] = self.api_base
+            # For Gemini, LiteLLM constructs the URL itself. If user provides a full Google endpoint
+            # as api_base, it might break the URL construction in LiteLLM.
+            # We only pass api_base if it doesn't look like a standard Google endpoint versioned URL.
+            is_google_endpoint = "generativelanguage.googleapis.com" in self.api_base and (
+                "/v1" in self.api_base or "/v1beta" in self.api_base
+            )
+            if not is_google_endpoint:
+                kwargs["api_base"] = self.api_base
         if self._extra_headers:
             kwargs["extra_headers"] = self._extra_headers
 

openviking/parse/parsers/directory.py

@@ -112,7 +112,8 @@ async def parse(
             viking_fs = self._get_viking_fs()
             temp_uri = self._create_temp_uri()
             target_uri = f"{temp_uri}/{dir_name}"
-            await viking_fs.mkdir(temp_uri)
+            await viking_fs.mkdir(temp_uri, exist_ok=True)
+            await viking_fs.mkdir(target_uri, exist_ok=True)
             await viking_fs.mkdir(target_uri)
 
             if not processable_files:

openviking/parse/parsers/markdown.py

@@ -529,7 +529,7 @@ async def _save_section(
 
         # Create directory and handle children or split
         section_dir = f"{parent_dir}/{name}"
-        await viking_fs.mkdir(section_dir)
+        await viking_fs.mkdir(section_dir, exist_ok=True)
 
         if has_children:
             await self._process_children(

openviking/parse/parsers/media/audio.py

@@ -91,7 +91,7 @@ async def parse(self, source: Union[str, Path], instruction: str = "", **kwargs)
         ext_no_dot = ext[1:] if ext else ""
         root_dir_name = VikingURI.sanitize_segment(f"{stem}_{ext_no_dot}")
         root_dir_uri = f"{temp_uri}/{root_dir_name}"
-        await viking_fs.mkdir(root_dir_uri)
+        await viking_fs.mkdir(root_dir_uri, exist_ok=True)
 
         # 1.1 Save original audio with original filename (sanitized)
         await viking_fs.write_file_bytes(f"{root_dir_uri}/{original_filename}", audio_bytes)

openviking/parse/parsers/media/image.py

@@ -106,7 +106,7 @@ async def parse(self, source: Union[str, Path], instruction: str = "", **kwargs)
         ext_no_dot = ext[1:] if ext else ""
         root_dir_name = VikingURI.sanitize_segment(f"{stem}_{ext_no_dot}")
         root_dir_uri = f"{temp_uri}/{root_dir_name}"
-        await viking_fs.mkdir(root_dir_uri)
+        await viking_fs.mkdir(root_dir_uri, exist_ok=True)
 
         # 1.1 Save original image with original filename (sanitized)
         await viking_fs.write_file_bytes(f"{root_dir_uri}/{original_filename}", image_bytes)

openviking/parse/parsers/media/video.py

@@ -91,7 +91,7 @@ async def parse(self, source: Union[str, Path], instruction: str = "", **kwargs)
         ext_no_dot = ext[1:] if ext else ""
         root_dir_name = VikingURI.sanitize_segment(f"{stem}_{ext_no_dot}")
         root_dir_uri = f"{temp_uri}/{root_dir_name}"
-        await viking_fs.mkdir(root_dir_uri)
+        await viking_fs.mkdir(root_dir_uri, exist_ok=True)
 
         # 1.1 Save original video with original filename (sanitized)
         await viking_fs.write_file_bytes(f"{root_dir_uri}/{original_filename}", video_bytes)

openviking/parse/tree_builder.py

@@ -248,7 +248,7 @@ async def _ensure_parent_dirs(self, uri: str, ctx: RequestContext) -> None:
 
         # Create parent directory (ignore if already exists)
         try:
-            await viking_fs.mkdir(parent_uri, ctx=ctx)
+            await viking_fs.mkdir(parent_uri, exist_ok=True, ctx=ctx)
             logger.debug(f"Created parent directory: {parent_uri}")
         except Exception as e:
             # Directory may already exist, ignore error

openviking/storage/queuefs/semantic_processor.py

@@ -318,6 +318,10 @@ async def _generate_text_summary(
 
         # Read file content (limit length)
         content = await viking_fs.read_file(file_path, ctx=active_ctx)
+
+        # Limit content length (about 10000 tokens)
+        max_chars = 30000
+        content = await viking_fs.read_file(file_path, ctx=active_ctx)
         if isinstance(content, bytes):
             # Try to decode with error handling for text files
             try:

openviking/storage/viking_fs.py

@@ -958,8 +958,37 @@ def _handle_agfs_read(self, result: Union[bytes, Any, None]) -> bytes:
             except Exception:
                 return b""
 
+    def _decode_bytes(self, data: bytes) -> str:
+        """Robustly decode bytes to string."""
+        if not data:
+            return ""
+        try:
+            return data.decode("utf-8")
+        except UnicodeDecodeError:
+            try:
+                # Try common encoding for Windows/legacy files in China
+                return data.decode("gbk")
+            except UnicodeDecodeError:
+                try:
+                    return data.decode("latin-1")
+                except UnicodeDecodeError:
+                    return data.decode("utf-8", errors="replace")
+
     def _handle_agfs_content(self, result: Union[bytes, Any, None]) -> str:
         """Handle AGFSClient content return types consistently."""
+        if isinstance(result, bytes):
+            return self._decode_bytes(result)
+        elif hasattr(result, "content") and result.content is not None:
+            return self._decode_bytes(result.content)
+        elif result is None:
+            return ""
+        else:
+            # Try to convert to string
+            try:
+                return str(result)
+            except Exception:
+                return ""
+        """Handle AGFSClient content return types consistently."""
         if isinstance(result, bytes):
             return result.decode("utf-8")
         elif hasattr(result, "content"):
@@ -1282,7 +1311,7 @@ async def append_file(
             existing = ""
             try:
                 existing_bytes = self._handle_agfs_read(self.agfs.read(path))
-                existing = existing_bytes.decode("utf-8")
+                existing = self._decode_bytes(existing_bytes)
             except Exception:
                 pass