feat(agent_example): create prompt example to instruction

Author: floritange

veadk/agent.py

@@ -56,7 +56,11 @@
 from veadk.utils.patches import patch_asyncio, patch_tracer
 from veadk.utils.misc import check_litellm_version
 from veadk.version import VERSION
-from veadk.prompts.prompt_example import AgentExample, format_examples
+from veadk.prompts.prompt_example import (
+    ExampleTool,
+    _convert_to_adk_examples,
+    AgentExample,
+)
 
 patch_tracer()
 patch_asyncio()
@@ -258,18 +262,14 @@ def model_post_init(self, __context: Any) -> None:
             else:
                 self.before_agent_callback = check_agent_authorization
 
-        if self.examples:
-            base = (
-                self.instruction
-                if isinstance(self.instruction, str)
-                else DEFAULT_INSTRUCTION
-            )
-            self.instruction = base + format_examples(self.examples)
-        print(self.instruction)
-
         if self.prompt_manager:
             self.instruction = self.prompt_manager.get_prompt
 
+        if self.examples:
+            adk_examples = _convert_to_adk_examples(self.examples)
+            self.tools.append(ExampleTool(adk_examples))
+            logger.info(f"Added {len(self.examples)} examples to agent")
+
         logger.info(f"VeADK version: {VERSION}")
 
         logger.info(f"{self.__class__.__name__} `{self.name}` init done.")

veadk/prompts/prompt_example.py

@@ -12,40 +12,47 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from dataclasses import dataclass
 from typing import Any, Union
+from pydantic import BaseModel, Field
+from google.genai import types
+from google.adk.examples.example import Example
 
 
-@dataclass
-class FunctionCallExample:
-    """Function call output example."""
+# === Add these classes before the Agent class ===
+class FunctionCallExample(BaseModel):
+    """Represents a function call output in an example."""
 
     func_name: str
-    func_args: dict[str, Any]
+    func_args: dict[str, Any] = Field(default_factory=dict)
 
 
-@dataclass
-class AgentExample:
-    """Input/output example for agent instruction."""
+class AgentExample(BaseModel):
+    """A few-shot example for the agent.
+
+    Attributes:
+        input: User input text.
+        output: Expected output - text string or function call.
+    """
 
     input: str
     output: Union[str, FunctionCallExample]
 
 
-def format_examples(examples: list[AgentExample]) -> str:
-    """Format examples as natural language string."""
-    if not examples:
-        return ""
-
-    lines = ["\n\n# Input/Output Example"]
-    for i, ex in enumerate(examples, 1):
-        lines.append(f"\nExample {i}:")
-        lines.append(f"- Input: {ex.input}")
+def _convert_to_adk_examples(examples: list[AgentExample]) -> list[Example]:
+    """Convert AgentExample list to ADK Example list."""
+    result = []
+    for ex in examples:
+        input_content = types.Content(
+            role="user", parts=[types.Part.from_text(text=ex.input)]
+        )
         if isinstance(ex.output, str):
-            lines.append(f"- Output: {ex.output}")
+            output_parts = [types.Part.from_text(text=ex.output)]
         else:
-            lines.append(
-                f"- Output: Call function `{ex.output.func_name}` with arguments {ex.output.func_args}"
-            )
-
-    return "\n".join(lines)
+            output_parts = [
+                types.Part.from_function_call(
+                    name=ex.output.func_name, args=ex.output.func_args
+                )
+            ]
+        output_content = [types.Content(role="model", parts=output_parts)]
+        result.append(Example(input=input_content, output=output_content))
+    return result