solace-agent-mesh 1.6.3__py3-none-any.whl → 1.7.1__py3-none-any.whl

solace_agent_mesh/agent/adk/adk_llm.txt

@@ -11,6 +11,7 @@ Once initialized, the `AppLlmAgent` (a custom agent class) is managed by the `ru
 - **Direct files:**
   - `__init__.py`: Standard Python package initializer
   - `adk_llm.txt`: Documentation file containing developer guide content
+  - `adk_llm_detail.txt`: Concatenated LLM summary file from all subdirectories
   - `app_llm_agent.py`: Defines a custom `LlmAgent` subclass that holds a reference to its host component
   - `callbacks.py`: Provides a rich set of ADK callback functions for dynamic instructions, metadata injection, and Solace integration
   - `embed_resolving_mcp_toolset.py`: Custom MCPToolset that resolves embeds in tool parameters before calling MCP tools
@@ -158,10 +159,11 @@ from solace_agent_mesh.agent.adk.artifacts.s3_artifact_service import S3Artifact
 
 #### models/
 **Purpose:** Contains concrete `BaseLlm` implementations for interfacing with various LLM providers
-**Key Exports:** `LiteLlm` class for broad model provider compatibility
+**Key Exports:** `LiteLlm` class for broad model provider compatibility, `OAuth2ClientCredentialsTokenManager` for OAuth authentication
 **Import Examples:**
 ```python
 from solace_agent_mesh.agent.adk.models.lite_llm import LiteLlm
+from solace_agent_mesh.agent.adk.models.oauth2_token_manager import OAuth2ClientCredentialsTokenManager
 ```
 
 ## Complete Usage Guide
@@ -198,7 +200,8 @@ from solace_agent_mesh.agent.adk.models.lite_llm import LiteLlm
 llm = LiteLlm(
     model="gpt-4-turbo",
     temperature=0.7,
-    max_completion_tokens=1000
+    max_completion_tokens=1000,
+    cache_strategy="5m"
 )
 
 # Anthropic
@@ -212,21 +215,12 @@ llm = LiteLlm(
     model="gemini-pro",
     temperature=0.3
 )
-```
-
-### 3. Artifact Service Usage
 
-```python
-from solace_agent_mesh.agent.adk.artifacts.filesystem_artifact_service import FilesystemArtifactService
-from solace_agent_mesh.agent.adk.artifacts.s3_artifact_service import S3ArtifactService
-from google.genai import types as adk_types
-
-# Initialize filesystem artifact service
-artifact_service = FilesystemArtifactService(base_path="/tmp/artifacts")
-
-# Or initialize S3 artifact service
-artifact_service = S3ArtifactService(bucket_name="my-artifacts-bucket")
-
-# Save an artifact
+# With OAuth authentication
+llm = LiteLlm(
+    model="custom-model",
+    oauth_token_url="https://auth.example.com/oauth/token",
+    oauth_client_id="your-client-id",
+    oauth_client_secret="your-client-secret",
 
-# content_hash: def8e8563d73ee6354aa959a4073a5474c225a2159f7c8fd37cf396040adeb5d
+# content_hash: c689f024368fe41a8310f8060beb396353bdb6708fb095fd2a1857ab21e68b50

solace_agent_mesh/agent/adk/artifacts/artifacts_llm.txt

@@ -168,4 +168,4 @@ await artifact_service.delete_artifact(
 )
 ```
 
-# content_hash: c4df3504afaa30b614cafc8cda2c977b18d0036faabaaec82b2f7a9bc5b082f6
+# content_hash: 8edcfe37e688e203ddb9d14f62b8e5f8dcb6129fc3c08816eea26de02ff6eb69

solace_agent_mesh/agent/adk/callbacks.py

@@ -170,13 +170,40 @@ async def process_artifact_blocks_callback(
                             event.params,
                         )
                         filename = event.params.get("filename", "unknown_artifact")
+                        if filename == "unknown_artifact":
+                            log.warning(
+                                "%s Fenced artifact block started without a 'filename' parameter.",
+                                log_identifier,
+                            )
+                        description = event.params.get("description")
+                        if filename == "unknown_artifact":
+                            log.warning(
+                                "%s Fenced artifact block started without a 'filename' parameter.",
+                                log_identifier,
+                            )
                         if a2a_context:
+                            status_text = f"Receiving artifact `{filename}`..."
+                            if description:
+                                status_text = (
+                                    f"Receiving artifact `{filename}`: {description}"
+                                )
                             progress_data = AgentProgressUpdateData(
-                                status_text=f"Receiving artifact `{filename}`..."
+                                status_text=status_text
                             )
                             await _publish_data_part_status_update(
                                 host_component, a2a_context, progress_data
                             )
+                            # Also send an initial in-progress event to create the UI bubble
+                            artifact_progress_data = ArtifactCreationProgressData(
+                                filename=filename,
+                                description=description,
+                                status="in-progress",
+                                bytes_transferred=0,
+                                artifact_chunk=None,
+                            )
+                            await _publish_data_part_status_update(
+                                host_component, a2a_context, artifact_progress_data
+                            )
                         params_str = " ".join(
                             [f'{k}="{v}"' for k, v in event.params.items()]
                         )
@@ -189,12 +216,19 @@ async def process_artifact_blocks_callback(
                             log_identifier,
                             event.buffered_size,
                         )
-                        params = parser._block_params
+                        params = event.params
                         filename = params.get("filename", "unknown_artifact")
+                        if filename == "unknown_artifact":
+                            log.warning(
+                                "%s Fenced artifact block progressed without a 'filename' parameter.",
+                                log_identifier,
+                            )
                         if a2a_context:
                             progress_data = ArtifactCreationProgressData(
                                 filename=filename,
-                                bytes_saved=event.buffered_size,
+                                description=params.get("description"),
+                                status="in-progress",
+                                bytes_transferred=event.buffered_size,
                                 artifact_chunk=event.chunk,
                             )
                             await _publish_data_part_status_update(
@@ -236,6 +270,18 @@ async def process_artifact_blocks_callback(
                                     "original_text": original_text,
                                 }
                             )
+                            if a2a_context:
+                                if not filename or not filename.strip():
+                                    filename = "unknown_artifact"
+                                progress_data = ArtifactCreationProgressData(
+                                    filename=filename or "unknown_artifact",
+                                    description=params.get("description"),
+                                    status="failed",
+                                    bytes_transferred=0,
+                                )
+                                await _publish_data_part_status_update(
+                                    host_component, a2a_context, progress_data
+                                )
                             continue
 
                         kwargs_for_call = {
@@ -257,7 +303,6 @@ async def process_artifact_blocks_callback(
                                     log_identifier,
                                     params["schema_max_keys"],
                                 )
-
                         wrapped_creator = ADKToolWrapper(
                             original_func=_internal_create_artifact,
                             tool_config=None,  # No specific config for this internal tool
@@ -299,9 +344,33 @@ async def process_artifact_blocks_callback(
                                     log_identifier,
                                     e_track,
                                 )
+                            # Publish completion status immediately via SSE
+                            if a2a_context:
+                                progress_data = ArtifactCreationProgressData(
+                                    filename=filename,
+                                    description=params.get("description"),
+                                    status="completed",
+                                    bytes_transferred=len(event.content),
+                                    mime_type=params.get("mime_type"),
+                                    version=version_for_tool,
+                                )
+                                await _publish_data_part_status_update(
+                                    host_component, a2a_context, progress_data
+                                )
                         else:
                             status_for_tool = "error"
                             version_for_tool = 0
+                            # Publish failure status immediately via SSE
+                            if a2a_context:
+                                progress_data = ArtifactCreationProgressData(
+                                    filename=filename,
+                                    description=params.get("description"),
+                                    status="failed",
+                                    bytes_transferred=len(event.content),
+                                )
+                                await _publish_data_part_status_update(
+                                    host_component, a2a_context, progress_data
+                                )
 
                         session.state["completed_artifact_blocks_list"].append(
                             {
@@ -347,6 +416,11 @@ async def process_artifact_blocks_callback(
                 )
                 params = event.params
                 filename = params.get("filename", "unknown_artifact")
+                if filename == "unknown_artifact":
+                    log.warning(
+                        "%s Unterminated fenced artifact block is missing a valid 'filename'. Failing operation.",
+                        log_identifier,
+                    )
                 if (
                     "completed_artifact_blocks_list" not in session.state
                     or session.state["completed_artifact_blocks_list"] is None
@@ -775,21 +849,55 @@ def _generate_fenced_artifact_instruction() -> str:
     close_delim = ARTIFACT_BLOCK_DELIMITER_CLOSE
     return f"""\
 **Creating Text-Based Artifacts:**
-To create an artifact from content you generate (like code, a report, or a document), you MUST use a special `save_artifact` block. This is the only reliable way to ensure your content is saved correctly.
 
-**Syntax:**
+**When to Create Text-based Artifacts:**
+Create an artifact when the content provides value as a standalone file:
+- Content with special formatting (HTML, Markdown, CSS, structured markup) that requires proper rendering
+- Content explicitly intended for use outside this conversation (reports, emails, presentations, reference documents)
+- Structured reference content users will save or follow (schedules, guides, templates)
+- Content that will be edited, expanded, or reused
+- Substantial text documents
+- Technical documentation meant as reference material
+
+**When NOT to Create Text-based Artifacts:**
+- Simple answers, explanations, or conversational responses
+- Brief advice, opinions, or quick information
+- Short lists, summaries, or single paragraphs  
+- Temporary content only relevant to the immediate conversation
+- Basic explanations that don't require reference material
+
+**Behaviour of created artifacts:** 
+- they are sent back to the UI inline with the text and show up as an interactive file component
+- the user can easily see the content so there is no need to return or embed it again.
+- do not embed the same artifact again, since the user already has it to expand and view
+
+**How to create artifacts:**
+To create an artifact from content you generate (like code, a report, or a document), you MUST use a fenced artifact block with the EXACT syntax shown below. This is the only reliable way to ensure your content is saved correctly.
+
+**EXACT SYNTAX (copy this pattern exactly):**
 {open_delim}save_artifact: filename="your_filename.ext" mime_type="text/plain" description="A brief description."
 The full content you want to save goes here.
 It can span multiple lines.
 {close_delim}
 
-- **Rules:**
-  - The parameters `filename` and `mime_type` are required. `description` is optional but recommended.
-  - All parameter values **MUST** be enclosed in double quotes.
-  - You **MUST NOT** use double quotes `"` inside the parameter values (e.g., within the description string). Use single quotes or rephrase instead.
-  - Do not surround a save_artifact block with '```' (triple backticks). This will create rendering issues.
-
-The system will automatically save the content and give you a confirmation in the next turn."""
+**CRITICAL FORMATTING RULES:**
+  1. The opening delimiter MUST be EXACTLY three angle brackets: `{open_delim}` (not `{open_delim[0:2]}` or `{open_delim[0:1]}`)
+  2. Immediately after the opening delimiter, write `save_artifact:` with a colon and NO space before the colon
+  3. Parameters (filename, mime_type, description) must be on the SAME line as the opening delimiter
+  4. All parameter values **MUST** be enclosed in double quotes: `filename="example.txt"`
+  5. You **MUST NOT** use double quotes `"` inside parameter values. Use single quotes or rephrase instead
+  6. After all parameters, press enter/newline, then write your content
+  7. Close the block with EXACTLY three angle brackets: `{close_delim}` on its own line
+  8. Do NOT surround the block with triple backticks (```). The delimiters `{open_delim}` and `{close_delim}` are sufficient
+
+**COMMON ERRORS TO AVOID:**
+  ❌ WRONG: `{open_delim[0:2]}save_artifact:` (only 2 angle brackets)
+  ❌ WRONG: `{open_delim[0:1]}save_artifact:` (only 1 angle bracket)
+  ❌ WRONG: `{open_delim}save_artifact` (missing colon)
+  ✅ CORRECT: `{open_delim}save_artifact: filename="test.txt" mime_type="text/plain"`
+
+The system will automatically save the content and give you a confirmation in the next turn by way of an automatically injected _notify_artifact_save tool call.
+"""
 
 
 def _generate_artifact_creation_instruction() -> str:
@@ -828,7 +936,7 @@ def _generate_embed_instruction(
     )
 
     base_instruction = f"""\
-You can use dynamic embeds in your text responses and tool parameters using the syntax {open_delim}type:expression {chain_delim} format{close_delim}. This allows you to
+You can use dynamic embeds in your text responses and tool parameters using the syntax {open_delim}type:expression {chain_delim} format{close_delim}. NOTE that this differs from 'save_artifact', which has  different delimiters. This allows you to
 always have correct information in your output. Specifically, make sure you always use embeds for math, even if it is simple. You will make mistakes if you try to do math yourself.
 Use HTML entities to escape the delimiters.
 This host resolves the following embed types *early* (before sending to the LLM or tool): {early_types}. This means the embed is replaced with its resolved value.
@@ -836,10 +944,18 @@ This host resolves the following embed types *early* (before sending to the LLM
 - `{open_delim}datetime:format_or_keyword{close_delim}`: Inserts current date/time. Use Python strftime format (e.g., `%Y-%m-%d`) or keywords (`iso`, `timestamp`, `date`, `time`, `now`).
 - `{open_delim}uuid:{close_delim}`: Inserts a random UUID.
 - `{open_delim}artifact_meta:filename[:version]{close_delim}`: Inserts a summary of the artifact's metadata (latest version if unspecified).
-- `{open_delim}status_update:Your message here{close_delim}`: Generates an immediate, distinct status message event that is displayed to the user (e.g., 'Thinking...', 'Searching database...'). This message appears in a status area, not as part of the main chat conversation. Use this to provide interim feedback during processing."""
+- `{open_delim}status_update:Your message here{close_delim}`: Generates an immediate, distinct status message event that is displayed to the user (e.g., 'Thinking...', 'Searching database...'). This message appears in a status area, not as part of the main chat conversation. Use this to provide interim feedback during processing.
+
+Examples:
+- `{open_delim}status_update:Analyzing data...{close_delim}` (Shows 'Analyzing data...' as a status update)
+- `The result of 23.5 * 4.2 is {open_delim}math:23.5 * 4.2 | .2f{close_delim}` (Embeds calculated result with 2 decimal places)
+
+The following embeds are resolved *late* (by the gateway before final display):
+- `{open_delim}artifact_return:filename[:version]{close_delim}`: **This is the primary way to return an artifact to the user.** It attaches the specified artifact to the message. The embed itself is removed from the text. Use this instead of describing a file and expecting the user to download it. Note: artifact_return is not necessary if the artifact was just created by you in this same response, since newly created artifacts are automatically attached to your message."""
 
     artifact_content_instruction = f"""
 - `{open_delim}artifact_content:filename[:version] {chain_delim} modifier1:value1 {chain_delim} ... {chain_delim} format:output_format{close_delim}`: Embeds artifact content after applying a chain of modifiers. This is resolved *late* (typically by a gateway before final display).
+    - If this embed resolves to binary content (like an image), it will be automatically converted into an attached file, similar to `artifact_return`.
     - Use `{chain_delim}` to separate the artifact identifier from the modifier steps and the final format step.
     - Available modifiers: {modifier_list}.
     - The `format:output_format` step *must* be the last step in the chain. Supported formats include `text`, `datauri`, `json`, `json_pretty`, `csv`. Formatting as datauri, will include the data URI prefix, so do not add it yourself.
@@ -860,7 +976,8 @@ This host resolves the following embed types *early* (before sending to the LLM
         - `{open_delim}artifact_content:products.csv {chain_delim} apply_to_template:product_table.html.mustache {chain_delim} format:text{close_delim}` (CSV is auto-parsed to `headers` and `data_rows` for the HTML template)
         - `{open_delim}artifact_content:config.json {chain_delim} jsonpath:$.userPreferences.theme {chain_delim} format:text{close_delim}` (Extract a single value from a JSON artifact)
         - `{open_delim}artifact_content:sensor_readings.csv {chain_delim} filter_rows_eq:status:critical {chain_delim} select_cols:timestamp,sensor_id,value {chain_delim} format:csv{close_delim}` (Filter critical sensor readings and select specific columns, output as CSV)
-        - `{open_delim}artifact_content:server.log {chain_delim} tail:100 {chain_delim} grep:WARN {chain_delim} format:text{close_delim}` (Get warning lines from the last 100 lines of a log file)"""
+        - `{open_delim}artifact_content:server.log {chain_delim} tail:100 {chain_delim} grep:WARN {chain_delim} format:text{close_delim}` (Get warning lines from the last 100 lines of a log file)
+"""
 
     final_instruction = base_instruction
     if include_artifact_content:
@@ -882,6 +999,10 @@ def _generate_tool_instructions_from_registry(
 
     instructions_by_category = defaultdict(list)
     for tool in sorted(active_tools, key=lambda t: (t.category, t.name)):
+        # Skip internal tools (those starting with underscore)
+        if tool.name.startswith("_"):
+            continue
+
         param_parts = []
         if tool.parameters and tool.parameters.properties:
             for name, schema in tool.parameters.properties.items():
@@ -947,15 +1068,12 @@ Simple, direct requests like 'create an image of a dog' or 'write an email to th
 
 If a plan is created:
 1. It should be a terse, hierarchical list describing the steps needed, with each checkbox item on its own line.
-2. Use '☐' (empty checkbox emoji) for pending items and '☑' (checked checkbox emoji) for completed items.
+2. Use '⬜' for pending items, '✅' for completed items, and '❌' for cancelled items.
 3. If the plan changes significantly during execution, restate the updated plan.
 4. As items are completed, update the plan to check them off.
 
 """
     injected_instructions.append(planning_instruction)
-    log.debug("%s Added hardcoded planning instructions.", log_identifier)
-    artifact_creation_instruction = _generate_artifact_creation_instruction()
-    injected_instructions.append(artifact_creation_instruction)
     fenced_artifact_instruction = _generate_fenced_artifact_instruction()
     injected_instructions.append(fenced_artifact_instruction)
 

solace_agent_mesh/agent/adk/embed_resolving_mcp_toolset.py

@@ -23,6 +23,7 @@ from ...common.utils.embeds import (
     evaluate_embed,
     resolve_embeds_in_string,
 )
+from ...common.utils.embeds.types import ResolutionMode
 from ..utils.context_helpers import get_original_session_id
 
 log = logging.getLogger(__name__)
@@ -184,6 +185,7 @@ class EmbedResolvingMCPTool(_BaseMcpToolClass):
                         context=resolution_context,
                         resolver_func=evaluate_embed,
                         types_to_resolve=EARLY_EMBED_TYPES.union(LATE_EMBED_TYPES),
+                        resolution_mode=ResolutionMode.TOOL_PARAMETER,
                         log_identifier=log_identifier,
                         config=self._tool_config,
                     )

solace_agent_mesh/agent/adk/models/lite_llm.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import base64
+import hashlib
 import json
 import logging
 from typing import Any
@@ -144,6 +145,38 @@ def _safe_json_serialize(obj) -> str:
         return str(obj)
 
 
+def _truncate_tool_call_id(tool_call_id: str, max_length: int = 40) -> str:
+    """Truncates tool call ID to meet OpenAI's maximum length requirement.
+    
+    OpenAI requires tool_call_id to be at most 40 characters. If the ID exceeds
+    this limit, we create a deterministic hash-based truncation to ensure:
+    1. The ID stays within the limit
+    2. The same input always produces the same output (deterministic)
+    3. Collisions are extremely unlikely
+    
+    Args:
+        tool_call_id: The original tool call ID
+        max_length: Maximum allowed length (default: 40 for OpenAI)
+    
+    Returns:
+        Truncated tool call ID that meets the length requirement
+    """
+    if len(tool_call_id) <= max_length:
+        return tool_call_id
+    
+    # Use first part of ID + hash of full ID to maintain uniqueness
+    # Format: prefix_hash where prefix is from original and hash ensures uniqueness
+    prefix_length = max_length - 33  # Reserve 33 chars for hash (32) + underscore (1)
+    if prefix_length < 1:
+        prefix_length = 1
+    
+    prefix = tool_call_id[:prefix_length]
+    # Use SHA256 and take first 32 hex characters for uniqueness
+    hash_suffix = hashlib.sha256(tool_call_id.encode()).hexdigest()[:32]
+    
+    return f"{prefix}_{hash_suffix}"
+
+
 def _content_to_message_param(
     content: types.Content,
 ) -> Union[Message, list[Message]]:
@@ -165,7 +198,7 @@ def _content_to_message_param(
             tool_messages.append(
                 ChatCompletionToolMessage(
                     role="tool",
-                    tool_call_id=part.function_response.id,
+                    tool_call_id=_truncate_tool_call_id(part.function_response.id),
                     content=_safe_json_serialize(part.function_response.response),
                 )
             )
@@ -185,7 +218,7 @@ def _content_to_message_param(
                 tool_calls.append(
                     ChatCompletionAssistantToolCall(
                         type="function",
-                        id=part.function_call.id,
+                        id=_truncate_tool_call_id(part.function_call.id),
                         function=Function(
                             name=part.function_call.name,
                             arguments=_safe_json_serialize(part.function_call.args),
@@ -464,7 +497,7 @@ def _message_to_generate_content_response(
                         name=tool_call.function.name,
                         args=json.loads(tool_call.function.arguments or "{}"),
                     )
-                    part.function_call.id = tool_call.id
+                    part.function_call.id = _truncate_tool_call_id(tool_call.id)
                     parts.append(part)
                 except json.JSONDecodeError as e:
                     logger.error(
@@ -887,7 +920,7 @@ class LiteLlm(BaseLlm):
                                 tool_calls.append(
                                     ChatCompletionMessageToolCall(
                                         type="function",
-                                        id=func_data["id"],
+                                        id=_truncate_tool_call_id(func_data["id"]),
                                         function=Function(
                                             name=func_data["name"],
                                             arguments=func_data["args"],
@@ -916,7 +949,7 @@ class LiteLlm(BaseLlm):
                                 tool_calls.append(
                                     ChatCompletionMessageToolCall(
                                         type="function",
-                                        id=func_data["id"],
+                                        id=_truncate_tool_call_id(func_data["id"]),
                                         function=Function(
                                             name=func_data["name"],
                                             arguments=func_data["args"],

solace_agent_mesh/agent/adk/models/models_llm.txt

@@ -5,6 +5,7 @@ This directory contains concrete implementations of the `BaseLlm` interface, pro
 
 ## Files Overview
 - `lite_llm.py` - LLM client using the `litellm` library to support hundreds of models from different providers
+- `oauth2_token_manager.py` - OAuth 2.0 Client Credentials token manager for LLM authentication
 
 ## Developer API Reference
 
@@ -14,7 +15,7 @@ This directory contains concrete implementations of the `BaseLlm` interface, pro
 **Import:** `from solace_agent_mesh.agent.adk.models.lite_llm import LiteLlm`
 
 **Classes:**
-- `LiteLlm(model: str, **kwargs)` - Wrapper around `litellm` supporting any model it recognizes
+- `LiteLlm(model: str, cache_strategy: str = "5m", **kwargs)` - Wrapper around `litellm` supporting any model it recognizes
   - `generate_content_async(llm_request: LlmRequest, stream: bool = False) -> AsyncGenerator[LlmResponse, None]` - Generates content asynchronously with optional streaming
   - `supported_models() -> list[str]` - Returns list of supported models (empty for LiteLlm due to dynamic model support)
   - `model: str` - The name of the LiteLlm model
@@ -64,7 +65,8 @@ async def main():
     llm = LiteLlm(
         model="gpt-4-turbo",
         temperature=0.7,
-        max_completion_tokens=150
+        max_completion_tokens=150,
+        cache_strategy="5m"  # Options: "none", "5m", "1h"
     )
     
     # Create a request
@@ -96,47 +98,92 @@ async def main():
         if response.usage_metadata:
             print(f"\nTotal tokens: {response.usage_metadata.total_token_count}")
 
-# Example with function calling
-async def function_calling_example():
-    from google.genai.types import FunctionDeclaration, Schema, Type, Tool
-    
-    # Define a function for the LLM to call
-    get_weather_func = FunctionDeclaration(
-        name="get_weather",
-        description="Get current weather for a location",
-        parameters=Schema(
-            type=Type.OBJECT,
-            properties={
-                "location": Schema(type=Type.STRING, description="City name"),
-                "unit": Schema(type=Type.STRING, description="Temperature unit")
-            },
-            required=["location"]
-        )
+# Example with OAuth authentication
+async def oauth_example():
+    llm = LiteLlm(
+        model="custom-model",
+        oauth_token_url="https://auth.example.com/oauth/token",
+        oauth_client_id="your-client-id",
+        oauth_client_secret="your-client-secret",
+        oauth_scope="llm.read llm.write",
+        oauth_ca_cert="/path/to/ca.crt",  # Optional
+        oauth_token_refresh_buffer_seconds=300,  # Optional
+        oauth_max_retries=3  # Optional
     )
     
-    llm = LiteLlm(model="gpt-4-turbo")
-    
     request = LlmRequest(
-        contents=[
-            Content(
-                role="user", 
-                parts=[Part.from_text("What's the weather like in Tokyo?")]
-            )
-        ],
-        config=LlmConfig(
-            tools=[Tool(function_declarations=[get_weather_func])]
-        )
+        contents=[Content(role="user", parts=[Part.from_text("Hello!")])]
     )
     
     async for response in llm.generate_content_async(request):
-        if response.function_calls:
-            for func_call in response.function_calls:
-                print(f"Function called: {func_call.name}")
-                print(f"Arguments: {func_call.args}")
+        print(response.text)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### oauth2_token_manager.py
+**Purpose:** Provides OAuth 2.0 Client Credentials flow implementation for LLM authentication with automatic token management, caching, and refresh capabilities.
+
+**Import:** `from solace_agent_mesh.agent.adk.models.oauth2_token_manager import OAuth2ClientCredentialsTokenManager`
+
+**Classes:**
+- `OAuth2ClientCredentialsTokenManager(token_url: str, client_id: str, client_secret: str, scope: Optional[str] = None, ca_cert_path: Optional[str] = None, refresh_buffer_seconds: int = 300, max_retries: int = 3)` - Manages OAuth 2.0 Client Credentials tokens with caching and automatic refresh
+  - `get_token() -> str` - Get a valid OAuth 2.0 access token (async)
+  - `token_url: str` - OAuth 2.0 token endpoint URL
+  - `client_id: str` - OAuth client identifier
+  - `client_secret: str` - OAuth client secret
+  - `scope: Optional[str]` - OAuth scope (space-separated string)
+  - `ca_cert_path: Optional[str]` - Path to custom CA certificate file
+  - `refresh_buffer_seconds: int` - Seconds before actual expiry to refresh token
+  - `max_retries: int` - Maximum number of retry attempts for token requests
+
+**Usage Examples:**
+```python
+import asyncio
+from solace_agent_mesh.agent.adk.models.oauth2_token_manager import OAuth2ClientCredentialsTokenManager
+
+async def main():
+    # Initialize OAuth token manager
+    token_manager = OAuth2ClientCredentialsTokenManager(
+        token_url="https://auth.example.com/oauth/token",
+        client_id="your-client-id",
+        client_secret="your-client-secret",
+        scope="llm.read llm.write",  # Optional
+        ca_cert_path="/path/to/ca.crt",  # Optional for custom CA
+        refresh_buffer_seconds=300,  # Refresh 5 minutes before expiry
+        max_retries=3  # Retry failed requests up to 3 times
+    )
+    
+    try:
+        # Get a valid access token
+        access_token = await token_manager.get_token()
+        print(f"Access token: {access_token[:20]}...")
+        
+        # Token is automatically cached and reused
+        # Subsequent calls will return cached token if still valid
+        cached_token = await token_manager.get_token()
+        print(f"Cached token: {cached_token[:20]}...")
+        
+    except Exception as e:
+        print(f"Failed to get OAuth token: {e}")
+
+# Example with custom SSL configuration
+async def custom_ssl_example():
+    token_manager = OAuth2ClientCredentialsTokenManager(
+        token_url="https://secure-auth.example.com/oauth/token",
+        client_id="client-123",
+        client_secret="secret-456",
+        ca_cert_path="/etc/ssl/certs/custom-ca.pem",  # Custom CA certificate
+        refresh_buffer_seconds=600,  # Refresh 10 minutes early
+        max_retries=5  # More retries for unreliable networks
+    )
+    
+    token = await token_manager.get_token()
+    print(f"Token obtained with custom SSL: {token[:20]}...")
 
 if __name__ == "__main__":
     asyncio.run(main())
-    # asyncio.run(function_calling_example())
 ```
 
-# content_hash: 97abaea0097e0d6fe18f1d747ed54ced092c0a96829dc5be8448b087ac5f7c20
+# content_hash: 29d771563355d8e4b320350d4fe586f19717d8b16707487efb4372125d5e0f10

solace_agent_mesh/agent/adk/runner.py

@@ -124,6 +124,15 @@ async def run_adk_async_task_thread_wrapper(
             a2a_context,
         )
 
+        # Mark task as paused if it's waiting for peer response or user input
+        if task_context and is_paused:
+            task_context.set_paused(True)
+            log.debug(
+                "%s Task %s marked as paused, waiting for peer response or user input.",
+                component.log_identifier,
+                logical_task_id,
+            )
+
         log.debug(
             "%s ADK task %s awaited and completed (Paused: %s).",
             component.log_identifier,

solace_agent_mesh/agent/adk/stream_parser.py

@@ -46,6 +46,7 @@ class BlockStartedEvent(ParserEvent):
 class BlockProgressedEvent(ParserEvent):
     """Emitted periodically while content is being buffered for a block."""
 
+    params: Dict[str, Any]
     buffered_size: int
     chunk: str
 
@@ -216,6 +217,10 @@ class FencedBlockStreamParser:
                     self._last_progress_update_size : current_size
                 ]
                 events.append(
-                    BlockProgressedEvent(buffered_size=current_size, chunk=new_chunk)
+                    BlockProgressedEvent(
+                        params=self._block_params,
+                        buffered_size=current_size,
+                        chunk=new_chunk,
+                    )
                 )
                 self._last_progress_update_size = current_size

solace_agent_mesh/agent/adk/tool_wrapper.py

@@ -15,6 +15,7 @@ from ...common.utils.embeds import (
     LATE_EMBED_TYPES,
     EMBED_DELIMITER_OPEN,
 )
+from ...common.utils.embeds.types import ResolutionMode
 
 log = logging.getLogger(__name__)
 
@@ -102,6 +103,7 @@ class ADKToolWrapper:
                         context=context_for_embeds,
                         resolver_func=evaluate_embed,
                         types_to_resolve=self._types_to_resolve,
+                        resolution_mode=ResolutionMode.TOOL_PARAMETER,
                         log_identifier=log_identifier,
                         config=self._tool_config,
                     )
@@ -123,6 +125,7 @@ class ADKToolWrapper:
                         context=context_for_embeds,
                         resolver_func=evaluate_embed,
                         types_to_resolve=self._types_to_resolve,
+                        resolution_mode=ResolutionMode.TOOL_PARAMETER,
                         log_identifier=log_identifier,
                         config=self._tool_config,
                     )