veadk-python 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

veadk/tools/builtin_tools/generate_image.py

@@ -25,24 +25,186 @@ from opentelemetry.trace import Span
 from volcenginesdkarkruntime import Ark
 from volcenginesdkarkruntime.types.images.images import SequentialImageGenerationOptions
 
-from veadk.config import getenv
-from veadk.consts import DEFAULT_IMAGE_GENERATE_MODEL_NAME, DEFAULT_MODEL_AGENT_API_BASE
+from veadk.config import getenv, settings
+from veadk.consts import (
+    DEFAULT_IMAGE_GENERATE_MODEL_NAME,
+    DEFAULT_IMAGE_GENERATE_MODEL_API_BASE,
+)
 from veadk.utils.logger import get_logger
-from veadk.utils.misc import formatted_timestamp, read_png_to_bytes
+from veadk.utils.misc import formatted_timestamp, read_file_to_bytes
 from veadk.version import VERSION
+import asyncio
+import concurrent.futures
+import contextvars
+
 
 logger = get_logger(__name__)
 
 client = Ark(
-    api_key=getenv("MODEL_AGENT_API_KEY"),
-    base_url=getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE),
+    api_key=getenv(
+        "MODEL_IMAGE_API_KEY", getenv("MODEL_AGENT_API_KEY", settings.model.api_key)
+    ),
+    base_url=getenv("MODEL_IMAGE_API_BASE", DEFAULT_IMAGE_GENERATE_MODEL_API_BASE),
 )
 
+executor = concurrent.futures.ThreadPoolExecutor(max_workers=8)
+tracer = trace.get_tracer("gcp.vertex.agent")
 
-async def image_generate(
-    tasks: list,
-    tool_context: ToolContext,
-) -> Dict:
+
+def _build_input_parts(item: dict, task_type: str, image_field):
+    input_part = {"role": "user"}
+    input_part["parts.0.type"] = "text"
+    input_part["parts.0.text"] = json.dumps(item, ensure_ascii=False)
+
+    if image_field:
+        if task_type.startswith("single"):
+            assert isinstance(image_field, str), (
+                f"single_* task_type image must be str, got {type(image_field)}"
+            )
+            input_part["parts.1.type"] = "image_url"
+            input_part["parts.1.image_url.name"] = "origin_image"
+            input_part["parts.1.image_url.url"] = image_field
+        elif task_type.startswith("multi"):
+            assert isinstance(image_field, list), (
+                f"multi_* task_type image must be list, got {type(image_field)}"
+            )
+            assert len(image_field) <= 10, (
+                f"multi_* task_type image list length must be <= 10, got {len(image_field)}"
+            )
+            for i, image_url in enumerate(image_field):
+                idx = i + 1
+                input_part[f"parts.{idx}.type"] = "image_url"
+                input_part[f"parts.{idx}.image_url.name"] = f"origin_image_{i}"
+                input_part[f"parts.{idx}.image_url.url"] = image_url
+
+    return input_part
+
+
+def handle_single_task_sync(
+    idx: int, item: dict, tool_context
+) -> tuple[list[dict], list[str]]:
+    logger.debug(f"handle_single_task_sync item {idx}: {item}")
+    success_list: list[dict] = []
+    error_list: list[str] = []
+    total_tokens = 0
+    output_tokens = 0
+    output_part = {"message.role": "model"}
+
+    task_type = item.get("task_type", "text_to_single")
+    prompt = item.get("prompt", "")
+    response_format = item.get("response_format", None)
+    size = item.get("size", None)
+    watermark = item.get("watermark", None)
+    image_field = item.get("image", None)
+    sequential_image_generation = item.get("sequential_image_generation", None)
+    max_images = item.get("max_images", None)
+
+    input_part = _build_input_parts(item, task_type, image_field)
+
+    inputs = {"prompt": prompt}
+    if size:
+        inputs["size"] = size
+    if response_format:
+        inputs["response_format"] = response_format
+    if watermark is not None:
+        inputs["watermark"] = watermark
+    if sequential_image_generation:
+        inputs["sequential_image_generation"] = sequential_image_generation
+
+    with tracer.start_as_current_span(f"call_llm_task_{idx}") as span:
+        try:
+            if (
+                sequential_image_generation
+                and sequential_image_generation == "auto"
+                and max_images
+            ):
+                response = client.images.generate(
+                    model=getenv("MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME),
+                    **inputs,
+                    sequential_image_generation_options=SequentialImageGenerationOptions(
+                        max_images=max_images
+                    ),
+                )
+            else:
+                response = client.images.generate(
+                    model=getenv("MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME),
+                    **inputs,
+                )
+
+            if not response.error:
+                logger.debug(f"task {idx} Image generate response: {response}")
+
+                total_tokens += getattr(response.usage, "total_tokens", 0) or 0
+                output_tokens += getattr(response.usage, "output_tokens", 0) or 0
+
+                for i, image_data in enumerate(response.data):
+                    image_name = f"task_{idx}_image_{i}"
+                    if "error" in image_data:
+                        logger.error(f"Image {image_name} error: {image_data.error}")
+                        error_list.append(image_name)
+                        continue
+
+                    if getattr(image_data, "url", None):
+                        image_url = image_data.url
+                    else:
+                        b64 = getattr(image_data, "b64_json", None)
+                        if not b64:
+                            logger.error(
+                                f"Image {image_name} missing data (no url/b64)"
+                            )
+                            error_list.append(image_name)
+                            continue
+                        image_bytes = base64.b64decode(b64)
+                        image_url = _upload_image_to_tos(
+                            image_bytes=image_bytes, object_key=f"{image_name}.png"
+                        )
+                        if not image_url:
+                            logger.error(f"Upload image to TOS failed: {image_name}")
+                            error_list.append(image_name)
+                            continue
+                        logger.debug(f"Image saved as ADK artifact: {image_name}")
+
+                    tool_context.state[f"{image_name}_url"] = image_url
+                    output_part[f"message.parts.{i}.type"] = "image_url"
+                    output_part[f"message.parts.{i}.image_url.name"] = image_name
+                    output_part[f"message.parts.{i}.image_url.url"] = image_url
+                    logger.debug(
+                        f"Image {image_name} generated successfully: {image_url}"
+                    )
+                    success_list.append({image_name: image_url})
+            else:
+                logger.error(
+                    f"Task {idx} No images returned by model: {response.error}"
+                )
+                error_list.append(f"task_{idx}")
+
+        except Exception as e:
+            logger.error(f"Error in task {idx}: {e}")
+            traceback.print_exc()
+            error_list.append(f"task_{idx}")
+
+        finally:
+            add_span_attributes(
+                span,
+                tool_context,
+                input_part=input_part,
+                output_part=output_part,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+                request_model=getenv(
+                    "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
+                ),
+                response_model=getenv(
+                    "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
+                ),
+            )
+    logger.debug(
+        f"task {idx} Image generate success_list: {success_list}\nerror_list: {error_list}"
+    )
+    return success_list, error_list
+
+
+async def image_generate(tasks: list[dict], tool_context) -> Dict:
     """
     Seedream 4.0: batch image generation via tasks.
     Args:
@@ -122,193 +284,72 @@ async def image_generate(
     - 如果想要指定生成组图的数量，请在prompt里添加数量说明，例如："生成3张图片"。
     - size 推荐使用 2048x2048 或表格里的标准比例，确保生成质量。
     """
-
+    logger.debug(
+        f"Using model: {getenv('MODEL_IMAGE_NAME', DEFAULT_IMAGE_GENERATE_MODEL_NAME)}"
+    )
     success_list: list[dict] = []
-    error_list = []
-
-    for idx, item in enumerate(tasks):
-        input_part = {"role": "user"}
-        output_part = {"message.role": "model"}
-        total_tokens = 0
-        output_tokens = 0
-        tracer = trace.get_tracer("gcp.vertex.agent")
-        with tracer.start_as_current_span("call_llm") as span:
-            task_type = item.get("task_type", "text_to_single")
-            prompt = item.get("prompt", "")
-            response_format = item.get("response_format", None)
-            size = item.get("size", None)
-            watermark = item.get("watermark", None)
-            image = item.get("image", None)
-            sequential_image_generation = item.get("sequential_image_generation", None)
-            max_images = item.get("max_images", None)
-
-            input_part["parts.0.type"] = "text"
-            input_part["parts.0.text"] = json.dumps(item, ensure_ascii=False)
-            inputs = {
-                "prompt": prompt,
-            }
-
-            if size:
-                inputs["size"] = size
-            if response_format:
-                inputs["response_format"] = response_format
-            if watermark:
-                inputs["watermark"] = watermark
-            if image:
-                if task_type.startswith("single"):
-                    assert isinstance(image, str), (
-                        f"single_* task_type image must be str, got {type(image)}"
-                    )
-                    input_part["parts.1.type"] = "image_url"
-                    input_part["parts.1.image_url.name"] = "origin_image"
-                    input_part["parts.1.image_url.url"] = image
-                elif task_type.startswith("multi"):
-                    assert isinstance(image, list), (
-                        f"multi_* task_type image must be list, got {type(image)}"
-                    )
-                    assert len(image) <= 10, (
-                        f"multi_* task_type image list length must be <= 10, got {len(image)}"
-                    )
-                    for i, image_url in enumerate(image):
-                        input_part[f"parts.{i + 1}.type"] = "image_url"
-                        input_part[f"parts.{i + 1}.image_url.name"] = (
-                            f"origin_image_{i}"
-                        )
-                        input_part[f"parts.{i + 1}.image_url.url"] = image_url
-
-            if sequential_image_generation:
-                inputs["sequential_image_generation"] = sequential_image_generation
-
-            try:
-                if (
-                    sequential_image_generation
-                    and sequential_image_generation == "auto"
-                    and max_images
-                ):
-                    response = client.images.generate(
-                        model=getenv(
-                            "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
-                        ),
-                        **inputs,
-                        sequential_image_generation_options=SequentialImageGenerationOptions(
-                            max_images=max_images
-                        ),
-                    )
-                else:
-                    response = client.images.generate(
-                        model=getenv(
-                            "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
-                        ),
-                        **inputs,
-                    )
-                if not response.error:
-                    for i, image_data in enumerate(response.data):
-                        image_name = f"task_{idx}_image_{i}"
-                        if "error" in image_data:
-                            error_details = (
-                                f"Image {image_name} error: {image_data.error}"
-                            )
-                            logger.error(error_details)
-                            error_list.append(image_name)
-                            continue
-                        if image_data.url:
-                            image = image_data.url
-                            tool_context.state[f"{image_name}_url"] = image
-
-                            output_part[f"message.parts.{i}.type"] = "image_url"
-                            output_part[f"message.parts.{i}.image_url.name"] = (
-                                image_name
-                            )
-                            output_part[f"message.parts.{i}.image_url.url"] = image
-
-                        else:
-                            image = image_data.b64_json
-                            image_bytes = base64.b64decode(image)
-
-                            tos_url = _upload_image_to_tos(
-                                image_bytes=image_bytes, object_key=f"{image_name}.png"
-                            )
-                            if tos_url:
-                                tool_context.state[f"{image_name}_url"] = tos_url
-                                image = tos_url
-                                output_part[f"message.parts.{i}.type"] = "image_url"
-                                output_part[f"message.parts.{i}.image_url.name"] = (
-                                    image_name
-                                )
-                                output_part[f"message.parts.{i}.image_url.url"] = image
-                            else:
-                                logger.error(
-                                    f"Upload image to TOS failed: {image_name}"
-                                )
-                                error_list.append(image_name)
-                                continue
-
-                            logger.debug(f"Image saved as ADK artifact: {image_name}")
-
-                        total_tokens += response.usage.total_tokens
-                        output_tokens += response.usage.output_tokens
-                        success_list.append({image_name: image})
-                else:
-                    error_details = (
-                        f"No images returned by Doubao model: {response.error}"
-                    )
-                    logger.error(error_details)
-                    error_list.append(f"task_{idx}")
-
-            except Exception as e:
-                error_details = f"Error: {e}"
-                logger.error(error_details)
-                traceback.print_exc()
-                error_list.append(f"task_{idx}")
-
-            add_span_attributes(
-                span,
-                tool_context,
-                input_part=input_part,
-                output_part=output_part,
-                output_tokens=output_tokens,
-                total_tokens=total_tokens,
-                request_model=getenv(
-                    "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
-                ),
-                response_model=getenv(
-                    "MODEL_IMAGE_NAME", DEFAULT_IMAGE_GENERATE_MODEL_NAME
-                ),
-            )
-    if len(success_list) == 0:
+    error_list: list[str] = []
+    logger.debug(f"image_generate tasks: {tasks}")
+    with tracer.start_as_current_span("image_generate"):
+        base_ctx = contextvars.copy_context()
+
+        def make_task(idx, item):
+            ctx = base_ctx.copy()
+            return lambda: ctx.run(handle_single_task_sync, idx, item, tool_context)
+
+        loop = asyncio.get_event_loop()
+        futures = [
+            loop.run_in_executor(executor, make_task(idx, item))
+            for idx, item in enumerate(tasks)
+        ]
+
+        results = await asyncio.gather(*futures, return_exceptions=True)
+
+        for res in results:
+            if isinstance(res, Exception):
+                logger.error(f"Task raised exception: {res}")
+                error_list.append("unknown_task_exception")
+                continue
+            s, e = res
+            success_list.extend(s)
+            error_list.extend(e)
+
+    if not success_list:
+        logger.debug(
+            f"image_generate success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "error",
             "success_list": success_list,
             "error_list": error_list,
         }
-    else:
-        app_name = tool_context._invocation_context.app_name
-        user_id = tool_context._invocation_context.user_id
-        session_id = tool_context._invocation_context.session.id
+    app_name = tool_context._invocation_context.app_name
+    user_id = tool_context._invocation_context.user_id
+    session_id = tool_context._invocation_context.session.id
+    artifact_service = tool_context._invocation_context.artifact_service
+
+    if artifact_service:
+        for image in success_list:
+            for _, image_tos_url in image.items():
+                filename = f"artifact_{formatted_timestamp()}"
+                await artifact_service.save_artifact(
+                    app_name=app_name,
+                    user_id=user_id,
+                    session_id=session_id,
+                    filename=filename,
+                    artifact=Part(
+                        inline_data=Blob(
+                            display_name=filename,
+                            data=read_file_to_bytes(image_tos_url),
+                            mime_type=mimetypes.guess_type(image_tos_url)[0],
+                        )
+                    ),
+                )
 
-        artifact_service = tool_context._invocation_context.artifact_service
-        if artifact_service:
-            for image in success_list:
-                for _, image_tos_url in image.items():
-                    filename = f"artifact_{formatted_timestamp()}"
-                    await artifact_service.save_artifact(
-                        app_name=app_name,
-                        user_id=user_id,
-                        session_id=session_id,
-                        filename=filename,
-                        artifact=Part(
-                            inline_data=Blob(
-                                display_name=filename,
-                                data=read_png_to_bytes(image_tos_url),
-                                mime_type=mimetypes.guess_type(image_tos_url)[0],
-                            )
-                        ),
-                    )
-        return {
-            "status": "success",
-            "success_list": success_list,
-            "error_list": error_list,
-        }
+    logger.debug(
+        f"image_generate success_list: {success_list}\nerror_list: {error_list}"
+    )
+    return {"status": "success", "success_list": success_list, "error_list": error_list}
 
 
 def add_span_attributes(

veadk/tools/builtin_tools/image_edit.py

@@ -15,8 +15,11 @@
 from typing import Dict
 from google.adk.tools import ToolContext
 from volcenginesdkarkruntime import Ark
-from veadk.config import getenv
-from veadk.consts import DEFAULT_MODEL_AGENT_API_BASE, DEFAULT_IMAGE_EDIT_MODEL_NAME
+from veadk.config import getenv, settings
+from veadk.consts import (
+    DEFAULT_IMAGE_EDIT_MODEL_API_BASE,
+    DEFAULT_IMAGE_EDIT_MODEL_NAME,
+)
 import base64
 from opentelemetry import trace
 import traceback
@@ -28,8 +31,10 @@ from veadk.utils.logger import get_logger
 logger = get_logger(__name__)
 
 client = Ark(
-    api_key=getenv("MODEL_AGENT_API_KEY"),
-    base_url=getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE),
+    api_key=getenv(
+        "MODEL_EDIT_API_KEY", getenv("MODEL_AGENT_API_KEY", settings.model.api_key)
+    ),
+    base_url=getenv("MODEL_EDIT_API_BASE", DEFAULT_IMAGE_EDIT_MODEL_API_BASE),
 )
 
 
@@ -92,9 +97,14 @@ async def image_edit(
         - Provide the same `seed` for consistent outputs across runs.
         - A high `guidance_scale` enforces stricter adherence to text prompt.
     """
+    logger.debug(
+        f"Using model: {getenv('MODEL_EDIT_NAME', DEFAULT_IMAGE_EDIT_MODEL_NAME)}"
+    )
     success_list = []
     error_list = []
+    logger.debug(f"image_edit params: {params}")
     for idx, item in enumerate(params):
+        logger.debug(f"image_edit item {idx}: {item}")
         image_name = item.get("image_name", f"generated_image_{idx}")
         prompt = item.get("prompt")
         origin_image = item.get("origin_image")
@@ -128,6 +138,7 @@ async def image_edit(
                 )
                 output_part = None
                 if response.data and len(response.data) > 0:
+                    logger.debug(f"task {idx} Image edit response: {response}")
                     for item in response.data:
                         if response_format == "url":
                             image = item.url
@@ -162,7 +173,9 @@ async def image_edit(
                                 continue
 
                             logger.debug(f"Image saved as ADK artifact: {image_name}")
-
+                        logger.debug(
+                            f"Image {image_name} generated successfully: {image}"
+                        )
                         success_list.append({image_name: image})
                 else:
                     error_details = f"No images returned by Doubao model: {response}"
@@ -191,12 +204,18 @@ async def image_edit(
             error_list.append(image_name)
 
     if len(success_list) == 0:
+        logger.debug(
+            f"image_edit success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "error",
             "success_list": success_list,
             "error_list": error_list,
         }
     else:
+        logger.debug(
+            f"image_edit success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "success",
             "success_list": success_list,

veadk/tools/builtin_tools/image_generate.py

@@ -15,8 +15,11 @@
 from typing import Dict
 
 from google.adk.tools import ToolContext
-from veadk.config import getenv
-from veadk.consts import DEFAULT_TEXT_TO_IMAGE_MODEL_NAME, DEFAULT_MODEL_AGENT_API_BASE
+from veadk.config import getenv, settings
+from veadk.consts import (
+    DEFAULT_TEXT_TO_IMAGE_MODEL_NAME,
+    DEFAULT_TEXT_TO_IMAGE_MODEL_API_BASE,
+)
 import base64
 from volcenginesdkarkruntime import Ark
 from opentelemetry import trace
@@ -29,8 +32,10 @@ from veadk.utils.logger import get_logger
 logger = get_logger(__name__)
 
 client = Ark(
-    api_key=getenv("MODEL_AGENT_API_KEY"),
-    base_url=getenv("MODEL_AGENT_API_BASE", DEFAULT_MODEL_AGENT_API_BASE),
+    api_key=getenv(
+        "MODEL_IMAGE_API_KEY", getenv("MODEL_AGENT_API_KEY", settings.model.api_key)
+    ),
+    base_url=getenv("MODEL_IMAGE_API_BASE", DEFAULT_TEXT_TO_IMAGE_MODEL_API_BASE),
 )
 
 
@@ -93,9 +98,14 @@ async def image_generate(
         - Use a fixed `seed` for reproducibility.
         - Choose appropriate `size` for desired aspect ratio.
     """
+    logger.debug(
+        f"Using model: {getenv('MODEL_IMAGE_NAME', DEFAULT_TEXT_TO_IMAGE_MODEL_NAME)}"
+    )
     success_list = []
     error_list = []
+    logger.debug(f"image_generate params: {params}")
     for idx, item in enumerate(params):
+        logger.debug(f"image_generate item {idx}: {item}")
         prompt = item.get("prompt", "")
         image_name = item.get("image_name", f"generated_image_{idx}")
         response_format = item.get("response_format", "url")
@@ -125,6 +135,7 @@ async def image_generate(
                 )
                 output_part = None
                 if response.data and len(response.data) > 0:
+                    logger.debug(f"task {idx} Image generate response: {response}")
                     for item in response.data:
                         if response_format == "url":
                             image = item.url
@@ -159,7 +170,9 @@ async def image_generate(
                                 continue
 
                             logger.debug(f"Image saved as ADK artifact: {image_name}")
-
+                        logger.debug(
+                            f"Image {image_name} generated successfully: {image}"
+                        )
                         success_list.append({image_name: image})
                 else:
                     error_details = f"No images returned by Doubao model: {response}"
@@ -187,12 +200,18 @@ async def image_generate(
             error_list.append(image_name)
 
     if len(success_list) == 0:
+        logger.debug(
+            f"image_generate success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "error",
             "success_list": success_list,
             "error_list": error_list,
         }
     else:
+        logger.debug(
+            f"image_generate success_list: {success_list}\nerror_list: {error_list}"
+        )
         return {
             "status": "success",
             "success_list": success_list,