Merge branch 'main' into RF/feat/integration-pipeline

Author: RoxyFarhad

.github/workflows/publish-pypi.yml

@@ -1,6 +1,6 @@
 # This workflow is triggered when a GitHub release is created.
 # It can also be run manually to re-publish to PyPI in case it failed for some reason.
-# You can run this workflow by navigating to https://www.github.com/scaleapi/agentex-python/actions/workflows/publish-pypi.yml
+# You can run this workflow by navigating to https://www.github.com/scaleapi/scale-agentex-python/actions/workflows/publish-pypi.yml
 name: Publish PyPI
 on:
   workflow_dispatch:

.github/workflows/release-doctor.yml

@@ -9,7 +9,7 @@ jobs:
   release_doctor:
     name: release doctor
     runs-on: ubuntu-latest
-    if: github.repository == 'scaleapi/agentex-python' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'release-please') || github.head_ref == 'next')
+    if: github.repository == 'scaleapi/scale-agentex-python' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'release-please') || github.head_ref == 'next')
 
     steps:
       - uses: actions/checkout@v4

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.5.0"
+  ".": "0.5.3"
 }

.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 34
 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sgp%2Fagentex-sdk-2b422fbf02ff3b77795fb8c71cbe784de3a3add48560655ba4fe7f3fcc509995.yml
 openapi_spec_hash: bca5c04d823694c87417dae188480291
-config_hash: 6481ea6b42040f435dedcb00a98f35f8
+config_hash: 0197f86ba1a4b1b5ce813d0e62138588

CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.5.3 (2025-10-31)
+
+Full Changelog: [v0.5.2...v0.5.3](https://github.com/scaleapi/scale-agentex-python/compare/v0.5.2...v0.5.3)
+
+### Chores
+
+* re apply example updates ([043973b](https://github.com/scaleapi/scale-agentex-python/commit/043973bec649ab2304eff7a313938e1e3e5377e5))
+
+## 0.5.2 (2025-10-31)
+
+Full Changelog: [v0.5.0...v0.5.2](https://github.com/scaleapi/scale-agentex-python/compare/v0.5.0...v0.5.2)
+
+### Features
+
+* **api:** manual updates ([dc66b57](https://github.com/scaleapi/scale-agentex-python/commit/dc66b57618525669b3aa15676343ef542675a5f9))
+* bump the helm chart version ([1ffafb0](https://github.com/scaleapi/scale-agentex-python/commit/1ffafb0406138d6abd84254fa394b88c4a28ce70))
+
+
+### Chores
+
+* sync repo ([0e05416](https://github.com/scaleapi/scale-agentex-python/commit/0e05416219ca93ae347e6175804bc0f2259a6b44))
+
 ## 0.5.0 (2025-10-28)
 
 Full Changelog: [v0.4.28...v0.5.0](https://github.com/scaleapi/agentex-python/compare/v0.4.28...v0.5.0)

CONTRIBUTING.md

@@ -62,7 +62,7 @@ If you’d like to use the repository from source, you can either install from g
 To install via git:
 
 ```sh
-$ pip install git+ssh://[email protected]/scaleapi/agentex-python.git
+$ pip install git+ssh://[email protected]/scaleapi/scale-agentex-python.git
 ```
 
 Alternatively, you can build from source and install the wheel file:
@@ -120,7 +120,7 @@ the changes aren't made through the automated pipeline, you may want to make rel
 
 ### Publish with a GitHub workflow
 
-You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/scaleapi/agentex-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up.
+You can release to package managers by using [the `Publish PyPI` GitHub action](https://www.github.com/scaleapi/scale-agentex-python/actions/workflows/publish-pypi.yml). This requires a setup organization or repository secret to be set up.
 
 ### Publish manually
 

README.md

@@ -268,9 +268,9 @@ task = response.parse()  # get the object that `tasks.list()` would have returne
 print(task)
 ```
 
-These methods return an [`APIResponse`](https://github.com/scaleapi/agentex-python/tree/main/src/agentex/_response.py) object.
+These methods return an [`APIResponse`](https://github.com/scaleapi/scale-agentex-python/tree/main/src/agentex/_response.py) object.
 
-The async client returns an [`AsyncAPIResponse`](https://github.com/scaleapi/agentex-python/tree/main/src/agentex/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
+The async client returns an [`AsyncAPIResponse`](https://github.com/scaleapi/scale-agentex-python/tree/main/src/agentex/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.
 
 #### `.with_streaming_response`
 
@@ -374,7 +374,7 @@ This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) con
 
 We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
 
-We are keen for your feedback; please open an [issue](https://www.github.com/scaleapi/agentex-python/issues) with questions, bugs, or suggestions.
+We are keen for your feedback; please open an [issue](https://www.github.com/scaleapi/scale-agentex-python/issues) with questions, bugs, or suggestions.
 
 ### Determining the installed version
 

examples/tutorials/00_sync/000_hello_acp/README.md

@@ -1,7 +1,44 @@
 # [Sync] Hello ACP
 
 This is a simple AgentEx agent that just says hello and acknowledges the user's message to show which ACP methods need to be implemented for the sync ACP type.
+The simplest agent type: synchronous request/response pattern with a single `@acp.on_message_send` handler. Best for stateless operations that complete immediately.
 
-## Official Documentation
+## What You'll Learn
+- Building a basic synchronous agent
+- The `@acp.on_message_send` handler pattern
+- When to use sync vs agentic agents
 
-[000 Hello ACP](https://dev.agentex.scale.com/docs/tutorials/sync/000_hello_acp)
+## Prerequisites
+- Development environment set up (see [main repo README](https://github.com/scaleapi/scale-agentex))
+- Backend services running: `make dev` from repository (agentex) root
+
+## Quick Start
+
+```bash
+cd examples/tutorials/00_sync/000_hello_acp
+uv run agentex agents run --manifest manifest.yaml
+```
+
+## Key Code
+
+```python
+@acp.on_message_send
+async def handle_message_send(params: SendMessageParams):
+    return TextContent(
+        author="agent",
+        content=f"Echo: {params.content.content}"
+    )
+```
+
+That's it - one handler, immediate response. No task creation, no state management.
+
+## When to Use
+- Simple chatbots with no memory requirements
+- Quick Q&A or information lookup agents
+- Prototyping and testing agent responses
+- Operations that complete in under a second
+
+## Why This Matters
+Sync agents are the simplest way to get started with AgentEx. They're perfect for learning the basics and building stateless agents. Once you need conversation memory or task tracking, you'll graduate to agentic agents.
+
+**Next:** [010_multiturn](../010_multiturn/) - Add conversation memory to your agent

examples/tutorials/00_sync/010_multiturn/README.md

@@ -1,7 +1,54 @@
 # [Sync] Multiturn
 
-This tutorial demonstrates how to handle multiturn conversations in AgentEx agents using the Agent 2 Client Protocol (ACP).
+Handle multi-turn conversations in synchronous agents by manually maintaining conversation history and context between messages.
 
-## Official Documentation
+## What You'll Learn
+- How to handle conversation history in sync agents
+- Building context from previous messages
+- The limitations of stateless multiturn patterns
 
-[010 Multiturn](https://dev.agentex.scale.com/docs/tutorials/sync/010_multiturn)
+## Prerequisites
+- Development environment set up (see [main repo README](https://github.com/scaleapi/scale-agentex))
+- Backend services running: `make dev` from repository root
+- Understanding of basic sync agents (see [000_hello_acp](../000_hello_acp/))
+
+## Quick Start
+
+```bash
+cd examples/tutorials/00_sync/010_multiturn
+uv run agentex agents run --manifest manifest.yaml
+```
+
+## Key Pattern
+
+Sync agents are stateless by default. To handle multi-turn conversations, you need to:
+1. Accept conversation history in the request
+2. Maintain context across messages
+3. Return responses that build on previous exchanges
+
+```python
+@acp.on_message_send
+async def handle_message_send(params: SendMessageParams):
+    # Accept conversation history from client
+    history = params.conversation_history
+
+    # Build context from history
+    context = build_context(history)
+
+    # Generate response considering full context
+    response = generate_response(params.content, context)
+
+    return TextContent(author="agent", content=response)
+```
+
+The handler accepts history, builds context, and returns responses that reference previous exchanges.
+
+## When to Use
+- Simple chatbots that need conversation memory
+- When client can maintain and send conversation history
+- Quick prototypes before building full agentic agents
+
+## Why This Matters
+While sync agents can handle conversations, you're responsible for managing state on the client side. This becomes complex quickly. For production conversational agents, consider agentic agents ([10_agentic/00_base/010_multiturn](../../10_agentic/00_base/010_multiturn/)) where the platform manages state automatically.
+
+**Next:** [020_streaming](../020_streaming/) - Stream responses in real-time

examples/tutorials/00_sync/010_multiturn/project/acp.py

@@ -1,14 +1,17 @@
 import os
 from typing import Union, AsyncGenerator
 
+from agents import Agent, Runner, RunConfig
+
 from agentex.lib import adk
 from agentex.types import TextContent
 from agentex.lib.types.acp import SendMessageParams
+from agentex.lib.types.converters import convert_task_messages_to_oai_agents_inputs
 from agentex.lib.utils.model_utils import BaseModel
-from agentex.lib.types.llm_messages import LLMConfig, UserMessage, SystemMessage, AssistantMessage
 from agentex.lib.sdk.fastacp.fastacp import FastACP
 from agentex.types.task_message_update import TaskMessageUpdate
 from agentex.types.task_message_content import TaskMessageContent
+from agentex.lib.adk.providers._modules.sync_provider import SyncStreamingProvider
 
 # Create an ACP server
 acp = FastACP.create(
@@ -66,21 +69,27 @@ async def handle_message_send(
     task_messages = await adk.messages.list(task_id=params.task.id)
 
     #########################################################
-    # 3. Convert task messages to LLM messages.
+    # 3. Run the agent with OpenAI Agents SDK
     #########################################################
 
-    # This might seem duplicative, but the split between TaskMessage and LLMMessage is intentional and important.
+    # Initialize the provider and run config to allow for tracing
+    provider = SyncStreamingProvider(
+        trace_id=params.task.id,
+    )
+
+    run_config = RunConfig(
+        model_provider=provider,
+    )
+
+    # Initialize the agent
+    test_agent = Agent(name="assistant", instructions=state.system_prompt, model=state.model)
+
+    # Convert task messages to OpenAI Agents SDK format
+    input_list = convert_task_messages_to_oai_agents_inputs(task_messages)
+
+    # Run the agent
+    result = await Runner.run(test_agent, input_list, run_config=run_config)
 
-    llm_messages = [
-        SystemMessage(content=state.system_prompt),
-        *[
-            UserMessage(content=getattr(message.content, "content", ""))
-            if getattr(message.content, "author", None) == "user"
-            else AssistantMessage(content=getattr(message.content, "content", ""))
-            for message in task_messages
-            if getattr(message.content, "type", None) == "text"
-        ],
-    ]
 
     # TaskMessages are messages that are sent between an Agent and a Client. They are fundamentally decoupled from messages sent to the LLM. This is because you may want to send additional metadata to allow the client to render the message on the UI differently.
 
@@ -94,25 +103,7 @@ async def handle_message_send(
     #   - If using multiple LLMs, but one LLM's output should not be sent to the user (i.e. a critic model), you can leverage the State as an internal storage mechanism to store the critic model's conversation history. This i s a powerful and flexible way to handle complex scenarios.
 
     #########################################################
-    # 4. Call an LLM to respond to the user's message.
+    # 4. Return the agent response to the client.
     #########################################################
 
-    # Call an LLM to respond to the user's message
-    chat_completion = await adk.providers.litellm.chat_completion(
-        llm_config=LLMConfig(model=state.model, messages=llm_messages),
-        trace_id=params.task.id,
-    )
-
-    #########################################################
-    # 5. Return the agent response to the client.
-    #########################################################
-
-    # The Agentex server automatically commits input and output messages to the database so you don't need to do this yourself, simply process the input content and return the output content.
-
-    # Return the agent response to the client
-    if chat_completion.choices[0].message:
-        content_str = chat_completion.choices[0].message.content or ""
-    else:
-        content_str = ""
-
-    return TextContent(author="agent", content=content_str)
+    return TextContent(author="agent", content=result.final_output)