pygpt-net 2.7.2__py3-none-any.whl → 2.7.4__py3-none-any.whl

pygpt_net/provider/api/google/image.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.25 20:00:00                  #
+# Updated Date: 2025.12.31 16:00:00                  #
 # ================================================== #
 
 import mimetypes
@@ -14,7 +14,7 @@ from typing import Optional, Dict, Any, List
 from google import genai
 from google.genai import types as gtypes
 from PySide6.QtCore import QObject, Signal, QRunnable, Slot
-import base64, datetime, os, requests
+import base64, datetime, os, requests, tempfile
 
 from pygpt_net.core.events import KernelEvent
 from pygpt_net.core.bridge.context import BridgeContext
@@ -55,6 +55,7 @@ class Image:
         prompt = context.prompt
         num = int(extra.get("num", 1))
         inline = bool(extra.get("inline", False))
+        extra_prompt = extra.get("extra_prompt", "")
 
         # decide sub-mode based on attachments
         sub_mode = self.MODE_GENERATE
@@ -79,6 +80,10 @@ class Image:
         worker.raw = self.window.core.config.get('img_raw')
         worker.num = num
         worker.inline = inline
+        worker.extra_prompt = extra_prompt
+
+        # remix: previous image reference (ID/URI/path) from extra
+        worker.image_id = extra.get("image_id")
 
         if attachments and len(attachments) > 0:
             mid = str(model.id).lower()
@@ -121,14 +126,16 @@ class ImageWorker(QRunnable):
         # params
         self.mode = Image.MODE_GENERATE
         self.attachments: Dict[str, Any] = {}
-        self.model = "imagen-4.0-generate-preview-06-06"
+        self.model = "imagen-4.0-generate-001"
         self.model_prompt = None
         self.input_prompt = ""
         self.system_prompt = ""
         self.inline = False
+        self.extra_prompt: Optional[str] = None
         self.raw = False
         self.num = 1
         self.resolution = "1024x1024"  # used to derive aspect ratio or image_size
+        self.image_id: Optional[str] = None  # remix/extend previous image
 
         # limits
         self.imagen_max_num = 4  # Imagen returns up to 4 images
@@ -174,10 +181,111 @@ class ImageWorker(QRunnable):
                     self.signals.error.emit(e)
                     self.signals.status.emit(trans('img.status.prompt.error') + ": " + str(e))
 
-            self.signals.status.emit(trans('img.status.generating') + f": {self.input_prompt}...")
+            # Decide how to apply negative prompt: native param on Vertex Imagen 3.0 (-001) or inline fallback.
+            use_param = (
+                bool(self.extra_prompt and str(self.extra_prompt).strip())
+                and self._using_vertex()
+                and self._imagen_supports_negative_prompt(self.model)
+            )
+            if (self.extra_prompt and str(self.extra_prompt).strip()) and not use_param:
+                try:
+                    self.input_prompt = self._merge_negative_prompt(self.input_prompt or "", self.extra_prompt)
+                except Exception:
+                    pass
 
             paths: List[str] = []
 
+            # Remix path: if image_id provided, prefer image-to-image remix using the given identifier.
+            if self.image_id:
+                self.signals.status.emit(trans('img.status.generating') + " (remix): " + (self.input_prompt or "") + "...")
+                if self._using_vertex() and self._is_imagen_generate(self.model):
+                    # Vertex / Imagen edit flow with a single base image (no explicit mask).
+                    img_ref = self._imagen_image_from_identifier(self.image_id)
+                    if not img_ref:
+                        raise RuntimeError("Invalid image_id for remix. Provide a valid local path, Files API name, or gs:// URI.")
+
+                    raw_ref = gtypes.RawReferenceImage(reference_id=0, reference_image=img_ref)
+                    mask_ref = gtypes.MaskReferenceImage(
+                        reference_id=1,
+                        reference_image=None,
+                        config=gtypes.MaskReferenceConfig(
+                            mask_mode="MASK_MODE_BACKGROUND",
+                            mask_dilation=0.0,
+                        ),
+                    )
+                    # Prepare edit config with optional negative prompt when supported
+                    cfg_kwargs = dict(
+                        edit_mode="EDIT_MODE_DEFAULT",
+                        number_of_images=min(self.num, self.imagen_max_num),
+                        include_rai_reason=True,
+                    )
+                    if self.extra_prompt and self._imagen_supports_negative_prompt(self.model):
+                        cfg_kwargs["negative_prompt"] = self.extra_prompt
+                    try:
+                        cfg = gtypes.EditImageConfig(**cfg_kwargs)
+                    except Exception:
+                        # Fallback without negative_prompt if SDK doesn't recognize it
+                        cfg_kwargs.pop("negative_prompt", None)
+                        cfg = gtypes.EditImageConfig(**cfg_kwargs)
+
+                    resp = self.client.models.edit_image(
+                        model="imagen-3.0-capability-001",
+                        prompt=self.input_prompt or "",
+                        reference_images=[raw_ref, mask_ref],
+                        config=cfg,
+                    )
+                    imgs = getattr(resp, "generated_images", None) or []
+                    for idx, gi in enumerate(imgs[: min(self.num, self.imagen_max_num)]):
+                        data = self._extract_imagen_bytes(gi)
+                        p = self._save(idx, data)
+                        if p:
+                            paths.append(p)
+
+                    # store reference for future remix: prefer remote URI if available, otherwise saved path
+                    if paths:
+                        self._store_image_reference_imagen(imgs[0] if imgs else None, paths[0])
+
+                else:
+                    # Gemini Developer API remix via generate_content with prompt + reference image part.
+                    ref_part = self._image_part_from_identifier(self.image_id)
+                    if not ref_part:
+                        raise RuntimeError("Invalid image_id for remix. Provide a valid local path, Files API name, http(s) URL, or gs:// URI.")
+                    img_cfg = self._build_gemini_image_config(self.model, self.resolution)
+                    resp = self.client.models.generate_content(
+                        model=self.model or self.DEFAULT_GEMINI_IMAGE_MODEL,
+                        contents=[self.input_prompt or "", ref_part],
+                        config=gtypes.GenerateContentConfig(
+                            image_config=img_cfg,
+                        ),
+                    )
+                    saved = 0
+                    for cand in getattr(resp, "candidates", []) or []:
+                        parts = getattr(getattr(cand, "content", None), "parts", None) or []
+                        for part in parts:
+                            inline = getattr(part, "inline_data", None)
+                            if inline and getattr(inline, "data", None):
+                                p = self._save(saved, inline.data)
+                                if p:
+                                    paths.append(p)
+                                    saved += 1
+                                    if saved >= self.num:
+                                        break
+                        if saved >= self.num:
+                            break
+
+                    # store reference: saved local path is a reusable identifier for next remix
+                    if paths:
+                        self._store_image_id(paths[0])
+
+                if self.inline:
+                    self.signals.finished_inline.emit(self.ctx, paths, self.input_prompt)
+                else:
+                    self.signals.finished.emit(self.ctx, paths, self.input_prompt)
+                return  # remix path finished
+
+            # Normal paths
+            self.signals.status.emit(trans('img.status.generating') + f": {self.input_prompt}...")
+
             if self.mode == Image.MODE_EDIT:
                 # EDIT
                 if self._using_vertex():
@@ -189,6 +297,9 @@ class ImageWorker(QRunnable):
                         p = self._save(idx, data)
                         if p:
                             paths.append(p)
+                    # store reference
+                    if paths:
+                        self._store_image_reference_imagen(imgs[0] if imgs else None, paths[0])
                 else:
                     # Gemini Developer API via Gemini image models (Nano Banana / Nano Banana Pro)
                     resp = self._gemini_edit(self.input_prompt, self.attachments, self.num)
@@ -206,6 +317,9 @@ class ImageWorker(QRunnable):
                                         break
                         if saved >= self.num:
                             break
+                    # store reference
+                    if paths:
+                        self._store_image_id(paths[0])
 
             else:
                 # GENERATE
@@ -218,6 +332,9 @@ class ImageWorker(QRunnable):
                         p = self._save(idx, data)
                         if p:
                             paths.append(p)
+                    # store reference
+                    if paths:
+                        self._store_image_reference_imagen(imgs[0] if imgs else None, paths[0])
                 else:
                     # Gemini Developer API image generation (Nano Banana / Nano Banana Pro) with robust sizing + optional reference images
                     resp = self._gemini_generate_image(self.input_prompt, self.model, self.resolution)
@@ -235,6 +352,9 @@ class ImageWorker(QRunnable):
                                         break
                         if saved >= self.num:
                             break
+                    # store reference
+                    if paths:
+                        self._store_image_id(paths[0])
 
             if self.inline:
                 self.signals.finished_inline.emit(self.ctx, paths, self.input_prompt)
@@ -260,12 +380,34 @@ class ImageWorker(QRunnable):
         mid = str(model_id).lower()
         return "imagen" in mid and "generate" in mid
 
+    def _imagen_supports_negative_prompt(self, model_id: str) -> bool:
+        """
+        Return True if the Imagen model supports native negative_prompt.
+        Supported: imagen-3.0-generate-001, imagen-3.0-fast-generate-001, imagen-3.0-capability-001.
+        """
+        mid = str(model_id or "").lower()
+        return any(x in mid for x in (
+            "imagen-3.0-generate-001",
+            "imagen-3.0-fast-generate-001",
+            "imagen-3.0-capability-001",
+        ))
+
     def _imagen_generate(self, prompt: str, num: int, resolution: str):
         """Imagen text-to-image."""
         aspect = self._aspect_from_resolution(resolution)
-        cfg = gtypes.GenerateImagesConfig(number_of_images=num)
+        # Build config with optional negative_prompt when supported by model and provided.
+        cfg_kwargs: Dict[str, Any] = {"number_of_images": num}
         if aspect:
-            cfg.aspect_ratio = aspect
+            cfg_kwargs["aspect_ratio"] = aspect
+        if self.extra_prompt and self._imagen_supports_negative_prompt(self.model):
+            cfg_kwargs["negative_prompt"] = self.extra_prompt
+        try:
+            cfg = gtypes.GenerateImagesConfig(**cfg_kwargs)
+        except Exception:
+            # Fallback without negative_prompt if SDK doesn't recognize it
+            cfg_kwargs.pop("negative_prompt", None)
+            cfg = gtypes.GenerateImagesConfig(**cfg_kwargs)
+
         return self.client.models.generate_images(
             model=self.model,
             prompt=prompt,
@@ -306,11 +448,19 @@ class ImageWorker(QRunnable):
             )
             edit_mode = "EDIT_MODE_BGSWAP"
 
-        cfg = gtypes.EditImageConfig(
+        # Build edit config with optional negative_prompt
+        cfg_kwargs = dict(
             edit_mode=edit_mode,
             number_of_images=min(num, self.imagen_max_num),
             include_rai_reason=True,
         )
+        if self.extra_prompt and self._imagen_supports_negative_prompt(self.model):
+            cfg_kwargs["negative_prompt"] = self.extra_prompt
+        try:
+            cfg = gtypes.EditImageConfig(**cfg_kwargs)
+        except Exception:
+            cfg_kwargs.pop("negative_prompt", None)
+            cfg = gtypes.EditImageConfig(**cfg_kwargs)
 
         # Ensure capability model for edit
         model_id = "imagen-3.0-capability-001"
@@ -397,9 +547,7 @@ class ImageWorker(QRunnable):
 
         def _do_call(icfg: Optional[gtypes.ImageConfig]):
             contents: List[Any] = []
-            # Always include the textual prompt (can be empty string).
             contents.append(prompt or "")
-            # Append reference images, if any.
             if image_parts:
                 contents.extend(image_parts)
             return self.client.models.generate_content(
@@ -461,6 +609,117 @@ class ImageWorker(QRunnable):
                     return _do_call(cfg2)
             raise
 
+    def _image_part_from_identifier(self, identifier: str) -> Optional[gtypes.Part]:
+        """
+        Build a Gemini Part from a generic image identifier:
+        - Local path -> Part.from_bytes
+        - Files API name (files/...) -> resolve to URI + mime and use Part.from_uri
+        - gs:// URI -> Part.from_uri
+        - http(s) URL -> download bytes and use Part.from_bytes
+        - data: URI (base64) -> decode and use Part.from_bytes
+        """
+        if not identifier:
+            return None
+        ident = str(identifier).strip()
+
+        # Local file
+        if os.path.exists(ident):
+            mime = self._guess_mime(ident)
+            with open(ident, "rb") as f:
+                return gtypes.Part.from_bytes(data=f.read(), mime_type=mime)
+
+        # Files API
+        if ident.startswith("files/"):
+            try:
+                f = self.client.files.get(name=ident)
+                file_uri = getattr(f, "uri", None)
+                mime = getattr(f, "mime_type", None) or self._guess_mime_from_uri(file_uri)
+                if file_uri and mime:
+                    return gtypes.Part.from_uri(file_uri=file_uri, mime_type=mime)
+            except Exception:
+                pass
+
+        # gs://
+        if ident.startswith("gs://"):
+            mime = self._guess_mime_from_uri(ident) or "image/png"
+            return gtypes.Part.from_uri(file_uri=ident, mime_type=mime)
+
+        # http(s)
+        if ident.startswith("http://") or ident.startswith("https://"):
+            try:
+                r = requests.get(ident, timeout=60)
+                if r.status_code == 200:
+                    mime = r.headers.get("Content-Type") or self._guess_mime_from_uri(ident) or "image/png"
+                    return gtypes.Part.from_bytes(data=r.content, mime_type=mime)
+            except Exception:
+                return None
+
+        # data:
+        if ident.startswith("data:"):
+            try:
+                head, b64 = ident.split(",", 1)
+                mime = head.split(";")[0][5:] if ";" in head else "image/png"
+                return gtypes.Part.from_bytes(data=base64.b64decode(b64), mime_type=mime)
+            except Exception:
+                return None
+
+        return None
+
+    def _imagen_image_from_identifier(self, identifier: str) -> Optional[gtypes.Image]:
+        """
+        Build a gtypes.Image for Imagen edit:
+        - Local path -> Image.from_file
+        - Files API name -> resolve to URI; if gs:// use gcs_uri, otherwise download to temp and from_file
+        - gs:// -> Image(gcs_uri=...)
+        - http(s) -> download to temp file, then from_file
+        """
+        if not identifier:
+            return None
+        ident = str(identifier).strip()
+
+        if os.path.exists(ident):
+            return gtypes.Image.from_file(location=ident)
+
+        if ident.startswith("files/"):
+            try:
+                f = self.client.files.get(name=ident)
+                uri = getattr(f, "uri", None)
+                if uri and uri.startswith("gs://"):
+                    return gtypes.Image(gcs_uri=uri)
+                if uri and (uri.startswith("http://") or uri.startswith("https://")):
+                    tmp = self._download_to_temp(uri)
+                    return gtypes.Image.from_file(location=tmp) if tmp else None
+            except Exception:
+                return None
+
+        if ident.startswith("gs://"):
+            return gtypes.Image(gcs_uri=ident)
+
+        if ident.startswith("http://") or ident.startswith("https://"):
+            tmp = self._download_to_temp(ident)
+            return gtypes.Image.from_file(location=tmp) if tmp else None
+
+        return None
+
+    def _download_to_temp(self, url: str) -> Optional[str]:
+        """Download URL to a temporary file and return its path."""
+        try:
+            r = requests.get(url, timeout=60)
+            if r.status_code == 200:
+                ext = ".png"
+                ct = r.headers.get("Content-Type") or ""
+                if "jpeg" in ct:
+                    ext = ".jpg"
+                elif "webp" in ct:
+                    ext = ".webp"
+                fd, path = tempfile.mkstemp(suffix=ext)
+                with os.fdopen(fd, "wb") as f:
+                    f.write(r.content)
+                return path
+        except Exception:
+            return None
+        return None
+
     def _collect_attachment_paths(self, attachments: Dict[str, Any]) -> List[str]:
         """Extract file paths from attachments dict."""
         out: List[str] = []
@@ -527,6 +786,34 @@ class ImageWorker(QRunnable):
                 pass
         return None
 
+    def _store_image_reference_imagen(self, generated_image_item: Any, fallback_path: Optional[str]) -> None:
+        """
+        Persist a reusable image reference to ctx.extra['image_id'].
+        Prefer remote URI/name if provided by Imagen; fallback to the saved local path.
+        """
+        ref = None
+        try:
+            img = getattr(generated_image_item, "image", None) if generated_image_item else None
+            if img:
+                ref = getattr(img, "uri", None) or getattr(img, "url", None) or getattr(img, "name", None)
+        except Exception:
+            ref = None
+        self._store_image_id(ref or fallback_path)
+
+    def _store_image_id(self, value: Optional[str]) -> None:
+        """
+        Store image_id reference in ctx.extra and persist the context item.
+        """
+        if not value:
+            return
+        try:
+            if not isinstance(self.ctx.extra, dict):
+                self.ctx.extra = {}
+            self.ctx.extra["image_id"] = str(value)
+            self.window.core.ctx.update_item(self.ctx)
+        except Exception:
+            pass
+
     def _save(self, idx: int, data: Optional[bytes]) -> Optional[str]:
         """Save image bytes to file and return path."""
         if not data:
@@ -559,6 +846,13 @@ class ImageWorker(QRunnable):
             return 'image/heic'
         return 'image/png'
 
+    def _guess_mime_from_uri(self, uri: Optional[str]) -> Optional[str]:
+        """Best-effort MIME guess from URI or file extension."""
+        if not uri:
+            return None
+        mime, _ = mimetypes.guess_type(uri)
+        return mime or None
+
     def _cleanup(self):
         """Cleanup resources."""
         sig = self.signals
@@ -567,4 +861,17 @@ class ImageWorker(QRunnable):
             try:
                 sig.deleteLater()
             except RuntimeError:
-                pass
+                pass
+
+    # ---------- prompt utilities ----------
+
+    @staticmethod
+    def _merge_negative_prompt(prompt: str, negative: Optional[str]) -> str:
+        """
+        Append a negative prompt to the main text prompt when the provider has no native negative_prompt field.
+        """
+        base = (prompt or "").strip()
+        neg = (negative or "").strip()
+        if not neg:
+            return base
+        return (base + ("\n" if base else "") + f"Negative prompt: {neg}").strip()

pygpt_net/provider/api/google/video.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.12.25 20:00:00                  #
+# Updated Date: 2025.12.31 16:00:00                  #
 # ================================================== #
 
 import base64, datetime, os, requests
@@ -54,6 +54,8 @@ class Video:
         prompt = context.prompt
         num = int(extra.get("num", 1))
         inline = bool(extra.get("inline", False))
+        video_id = extra.get("video_id")
+        extra_prompt = extra.get("extra_prompt", "")
 
         # decide sub-mode based on attachments (image-to-video when image is attached)
         sub_mode = self.MODE_GENERATE
@@ -80,6 +82,8 @@ class Video:
         worker.raw = self.window.core.config.get('img_raw')
         worker.num = num
         worker.inline = inline
+        worker.extra_prompt = extra_prompt
+        worker.video_id = video_id
 
         # optional params
         worker.aspect_ratio = str(extra.get("aspect_ratio") or self.window.core.config.get('video.aspect_ratio') or "16:9")
@@ -141,6 +145,8 @@ class VideoWorker(QRunnable):
         self.input_prompt = ""
         self.system_prompt = ""
         self.inline = False
+        self.extra_prompt: Optional[str] = None
+        self.video_id = None
         self.raw = False
         self.num = 1
 
@@ -149,7 +155,6 @@ class VideoWorker(QRunnable):
         self.duration_seconds = 8
         self.fps = 24
         self.seed: Optional[int] = None
-        self.negative_prompt: Optional[str] = None
         self.generate_audio: bool = False  # generation includes audio by default on Veo 3.x
         self.resolution: str = "720p"      # Veo supports 720p/1080p depending on variant
 
@@ -162,6 +167,7 @@ class VideoWorker(QRunnable):
     @Slot()
     def run(self):
         try:
+            kernel = self.window.controller.kernel
             # optional prompt enhancement
             if not self.raw and not self.inline and self.input_prompt:
                 try:
@@ -201,13 +207,80 @@ class VideoWorker(QRunnable):
             # set optional controls
             if self.seed is not None:
                 cfg_kwargs["seed"] = int(self.seed)
-            if self.negative_prompt:
-                cfg_kwargs["negative_prompt"] = self.negative_prompt
+            if self.extra_prompt:
+                cfg_kwargs["negative_prompt"] = self.extra_prompt
 
             # set durationSeconds when supported; fall back gracefully if rejected by model
             cfg_try = dict(cfg_kwargs)
             cfg_try["duration_seconds"] = int(self._duration_for_model(self.model, self.duration_seconds))
 
+            # remix / extension: if video_id provided, prefer video-to-video path
+            is_remix = bool(self.video_id)
+            if is_remix:
+                # Veo extension support varies by API and model; choose a compatible model if needed
+                model_for_ext = self._select_extension_model(self.model)
+                if model_for_ext != self.model:
+                    self.signals.status.emit(f"Please switch model for extension: {self.model} -> {model_for_ext}")
+                    # self.model = model_for_ext # <-- do not override user selection, just inform
+
+                # Build video input from identifier (URI, files/<id>, http(s), gs://, or local path)
+                video_input = self._video_from_identifier(self.video_id)
+                if not video_input:
+                    raise RuntimeError("Invalid video_id for remix/extension. Provide a valid URI, file name, or local path.")
+
+                # Minimal config for extension to avoid server-side rejections
+                ext_config = gtypes.GenerateVideosConfig(number_of_videos=1)
+                # Pass negative prompt to extension when provided
+                if self.extra_prompt:
+                    ext_config.negative_prompt = self.extra_prompt  # supported in python-genai
+
+                label = trans('vid.status.generating') + " (remix)"
+                self.signals.status.emit(label + f": {self.input_prompt or ''}...")
+
+                # Start operation: video extension, prompt optional
+                operation = self.client.models.generate_videos(
+                    model=self.model or self.DEFAULT_VEO_MODEL,
+                    prompt=self.input_prompt or "",
+                    video=video_input,
+                    config=ext_config,
+                )
+
+                # poll until done
+                while not getattr(operation, "done", False):
+                    if kernel.stopped():
+                        break
+                    time.sleep(10)
+                    if kernel.stopped():
+                        break
+                    operation = self.client.operations.get(operation)
+
+                # extract response payload
+                op_resp = getattr(operation, "response", None) or getattr(operation, "result", None)
+                if not op_resp:
+                    raise RuntimeError("Empty operation response.")
+
+                gen_list = getattr(op_resp, "generated_videos", None) or []
+                if not gen_list:
+                    raise RuntimeError("No videos generated.")
+
+                # store remote reference for next remix calls (URI/name) in ctx
+                self._store_video_reference(gen_list[0])
+
+                # download and save
+                paths: List[str] = []
+                for idx, gv in enumerate(gen_list[:1]):
+                    data = self._download_video_bytes(getattr(gv, "video", None))
+                    p = self._save(idx, data)
+                    if p:
+                        paths.append(p)
+
+                if self.inline:
+                    self.signals.finished_inline.emit(self.ctx, paths, self.input_prompt)
+                else:
+                    self.signals.finished.emit(self.ctx, paths, self.input_prompt)
+                return  # remix path completed
+
+            # normal generation path (text-to-video or image-to-video)
             self.signals.status.emit(trans('vid.status.generating') + f": {self.input_prompt}...")
 
             try:
@@ -235,7 +308,11 @@ class VideoWorker(QRunnable):
 
             # poll until done
             while not getattr(operation, "done", False):
+                if kernel.stopped():
+                    break
                 time.sleep(10)
+                if kernel.stopped():
+                    break
                 operation = self.client.operations.get(operation)
 
             # extract response payload
@@ -247,6 +324,9 @@ class VideoWorker(QRunnable):
             if not gen_list:
                 raise RuntimeError("No videos generated.")
 
+            # store remote reference for potential future remix/extension
+            self._store_video_reference(gen_list[0])
+
             # download and save all outputs up to num
             paths: List[str] = []
             for idx, gv in enumerate(gen_list[:num]):
@@ -329,6 +409,82 @@ class VideoWorker(QRunnable):
                 continue
         return None
 
+    def _video_from_identifier(self, identifier: str) -> Optional[gtypes.Video]:
+        """
+        Build a Video object from a generic identifier:
+        - Local file path -> upload via types.Video.from_file
+        - files/<id> -> resolve to URI using Files API
+        - http(s) or gs:// URI -> pass-through
+        """
+        try:
+            if not identifier:
+                return None
+            ident = str(identifier).strip()
+
+            # Local path
+            if os.path.exists(ident):
+                return gtypes.Video.from_file(ident)
+
+            # Files API name
+            if ident.startswith("files/"):
+                try:
+                    f = self.client.files.get(name=ident)
+                    uri = getattr(f, "uri", None)
+                    if uri:
+                        return gtypes.Video(uri=uri)
+                except Exception:
+                    pass
+
+            # Generic URI (Gemini accepts URIs, Vertex expects GCS; SDK honors both via uri field)
+            if ident.startswith("http://") or ident.startswith("https://") or ident.startswith("gs://"):
+                return gtypes.Video(uri=ident)
+        except Exception:
+            return None
+        return None
+
+    def _select_extension_model(self, model_id: str) -> str:
+        """
+        Choose a compatible model for video extension:
+        - Gemini API: Veo 3.1 only supports extension
+        - Vertex AI: extension supported on Veo 2.0
+        """
+        mid = str(model_id or "").lower()
+        use_vertex = bool(getattr(self.client, "vertexai", False))
+
+        # Gemini Developer API path
+        if not use_vertex:
+            if "veo-3.1" in mid:
+                return model_id
+            # Prefer 3.1 preview if user selected older Veo
+            return "veo-3.1-generate-preview"
+
+        # Vertex AI path
+        if "veo-2.0" in mid:
+            return model_id
+        return "veo-2.0-generate-001"
+
+    def _store_video_reference(self, generated_video_item: Any) -> None:
+        """
+        Persist a reusable video reference (URI or name) to ctx.extra['video_id'] for future remix/extension calls.
+        """
+        try:
+            vref = getattr(generated_video_item, "video", None)
+            if not vref:
+                return
+            # Prefer URI, fallback to name
+            uri = getattr(vref, "uri", None) or getattr(vref, "download_uri", None)
+            name = getattr(vref, "name", None)
+            ref = uri or name
+            if not ref:
+                return
+
+            if not isinstance(self.ctx.extra, dict):
+                self.ctx.extra = {}
+            self.ctx.extra["video_id"] = ref
+            self.window.core.ctx.update_item(self.ctx)
+        except Exception:
+            pass
+
     def _download_video_bytes(self, file_ref) -> Optional[bytes]:
         """
         Download video bytes using the Files service.