Merge branch 'v1.16' into redis-sentinel-multiple-addresses

Author: marcduiker

.gitmodules

@@ -1,25 +1,4 @@
-[submodule "sdkdocs/python"]
-	path = sdkdocs/python
-	url = https://github.com/dapr/python-sdk.git
-[submodule "sdkdocs/php"]
-	path = sdkdocs/php
-	url = https://github.com/dapr/php-sdk.git
 [submodule "translations/docs-zh"]
 	path = translations/docs-zh
 	url = https://github.com/dapr/docs-zh.git
-	branch = v1.0_content
-[submodule "sdkdocs/go"]
-	path = sdkdocs/go
-	url = https://github.com/dapr/go-sdk.git
-[submodule "sdkdocs/java"]
-	path = sdkdocs/java
-	url = https://github.com/dapr/java-sdk.git
-[submodule "sdkdocs/js"]
-	path = sdkdocs/js
-	url = https://github.com/dapr/js-sdk.git 
-[submodule "sdkdocs/pluggable-components/go"]
-	path = sdkdocs/pluggable-components/go
-	url = https://github.com/dapr-sandbox/components-go-sdk
-[submodule "sdkdocs/rust"]
-	path = sdkdocs/rust
-	url = https://github.com/dapr/rust-sdk.git
+	branch = v1.0_content

README.md

@@ -76,10 +76,9 @@ Continue with the [Run local server](#run-local-server) steps.
 git submodule update --init --recursive
 ```
 
-1. Navigate back to the repository root and install npm packages:
+1. Install the npm packages:
 
 ```sh
-cd ..
 npm install
 ```
 

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-core-concepts.md

@@ -53,19 +53,11 @@ Make sure you have Python already installed. `Python >=3.10`. For installation i
 
 Let's create a weather assistant agent that demonstrates tool calling with Dapr state management used for conversation memory.
 
-### 1. Create the environment file
+### 1. Create the Dapr components
 
-Create a `.env` file with your OpenAI API key:
+Create a `components` directory and add two files:
 
-```env
-OPENAI_API_KEY=your_api_key_here
-```
-
-This API key is essential for agents to communicate with the LLM, as the default LLM client in the agent uses OpenAI's services. If you don't have an API key, you can [create one here](https://platform.openai.com/api-keys).
-
-### 2. Create the Dapr component
-
-Create a `components` directory and add `historystore.yaml`:
+`historystore.yaml`:
 
 ```yaml
 apiVersion: dapr.io/v1alpha1
@@ -84,36 +76,67 @@ spec:
 
 This component will be used to store the conversation history, as LLMs are stateless and every chat interaction needs to send all the previous conversations to maintain context.
 
+`openai.yaml`:
+
+```yaml
+apiVersion: dapr.io/v1alpha1
+kind: Component
+metadata:
+  name: openai
+spec:
+  type: conversation.openai
+  version: v1
+  metadata:
+  - name: key
+    value: "{{OPENAI_API_KEY}}"
+  - name: model
+    value: gpt-5-2025-08-07
+  - name: temperature
+    value: 1
+```
+
+This component wires the default `DaprChatClient` to OpenAI via the Conversation API. Replace the `{{OPENAI_API_KEY}}` placeholder with your actual OpenAI key by editing the file directly. This API key is essential for agents to communicate with the LLM, as the default chat client talks to OpenAI-compatible endpoints. If you don't have an API key, you can [create one here](https://platform.openai.com/api-keys). You can also tweak metadata (model, temperature, baseUrl, etc.) to point at compatible OpenAI-style providers.
+
 ### 3. Create the agent with weather tool
 
 Create `weather_agent.py`:
 
 ```python
 import asyncio
 from dapr_agents import tool, Agent
+from dapr_agents.agents.configs import AgentMemoryConfig
 from dapr_agents.memory import ConversationDaprStateMemory
 from dotenv import load_dotenv
 
 load_dotenv()
 
+
 @tool
 def get_weather() -> str:
     """Get current weather."""
     return "It's 72°F and sunny"
 
+
 async def main():
+    memory_config = AgentMemoryConfig(
+        store=ConversationDaprStateMemory(
+            store_name="historystore",
+            session_id="hello-world",
+        )
+    )
+
     agent = Agent(
         name="WeatherAgent",
         role="Weather Assistant",
         instructions=["Help users with weather information"],
-        memory=ConversationDaprStateMemory(store_name="historystore", session_id="hello-world"),
+        memory=memory_config,
         tools=[get_weather],
     )
 
     # First interaction
     response1 = await agent.run("Hi! My name is John. What's the weather?")
     print(f"Agent: {response1}")
-    
+
     # Second interaction - agent should remember the name
     response2 = await agent.run("What's my name?")
     print(f"Agent: {response2}")
@@ -184,4 +207,4 @@ Here you can browse the state store used in the agent and explore its data.
 ## Next Steps
 
 Now that you have Dapr Agents installed and running, explore more advanced examples and patterns in the [quickstarts]({{% ref dapr-agents-quickstarts.md %}}) section to learn about multi-agent workflows, durable agents, and integration with Dapr's powerful distributed capabilities.
- 
+ 

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-getting-started.md

@@ -362,7 +362,19 @@ The Durable Agent also enables the "headless agents" approach where autonomous s
 **Implementation with Dapr Agents:**
 
 ```python
+import asyncio
+
 from dapr_agents import DurableAgent
+from dapr_agents.agents.configs import (
+    AgentExecutionConfig,
+    AgentMemoryConfig,
+    AgentPubSubConfig,
+    AgentRegistryConfig,
+    AgentStateConfig,
+)
+from dapr_agents.memory import ConversationDaprStateMemory
+from dapr_agents.storage.daprstores.stateservice import StateStoreService
+from dapr_agents.workflow.runners import AgentRunner
 
 travel_planner = DurableAgent(
     name="TravelBuddy",
@@ -371,23 +383,58 @@ travel_planner = DurableAgent(
     instructions=[
         "Find flights to destinations",
         "Remember user preferences",
-        "Provide clear flight info"
+        "Provide clear flight info",
     ],
     tools=[search_flights],
-    message_bus_name="messagepubsub",
-    state_store_name="workflowstatestore",
-    state_key="workflow_state",
-    agents_registry_store_name="workflowstatestore",
-    agents_registry_key="agents_registry",
+    pubsub=AgentPubSubConfig(
+        pubsub_name="messagepubsub",
+        agent_topic="travel.requests",
+        broadcast_topic="travel.broadcast",
+    ),
+    state=AgentStateConfig(
+        store=StateStoreService(store_name="workflowstatestore"),
+    ),
+    registry=AgentRegistryConfig(
+        store=StateStoreService(store_name="registrystatestore"),
+        team_name="travel-team",
+    ),
+    execution=AgentExecutionConfig(max_iterations=3),
+    memory=AgentMemoryConfig(
+        store=ConversationDaprStateMemory(
+            store_name="conversationstore",
+            session_id="travel-session",
+        )
+    ),
 )
+
+async def main():
+    travel_planner.start()
+    runner = AgentRunner()
+    try:
+        result = await runner.run(
+            travel_planner,
+            payload={"task": "Find weekend flights to Paris"},
+        )
+        print(result)
+    finally:
+        runner.shutdown()
+        travel_planner.stop()
+
+asyncio.run(main())
 ```
 The implementation follows Dapr's sidecar architecture model, where all infrastructure concerns are handled by the Dapr runtime:
 - **Persistent Memory** - Agent state is stored in Dapr's state store, surviving process crashes
 - **Workflow Orchestration** - All agent interactions managed through Dapr's workflow system
-- **Service Exposure** - REST endpoints for workflow management come out of the box
-- **Pub/Sub Input/Output** - Event-driven messaging through Dapr's pub/sub system for seamless integration
+- **Service Exposure** - `AgentRunner.serve()` exposes REST endpoints (e.g., `POST /run`) that schedule the agent's `@workflow_entry`
+- **Pub/Sub Input/Output** - `AgentRunner.subscribe()` scans the agent for `@message_router` methods and wires the configured topics with schema validation
+
+The Durable Agent enables the concept of "headless agents" - autonomous systems that operate without direct user interaction. Depending on the scenario you can:
+
+1. **Run** durable workflows programmatically (`runner.run` as shown above)
+2. **Subscribe** the agent to topics so other services can trigger it via pub/sub (`runner.subscribe`)
+3. **Serve** the agent behind a FastAPI app with built-in `/run` and status endpoints (`runner.serve`)
 
-The Durable Agent enables the concept of "headless agents" - autonomous systems that operate without direct user interaction. Dapr's Durable Agent exposes both REST and Pub/Sub APIs, making it ideal for long-running operations that are triggered by other applications or external events. This allows agents to run in the background, processing requests asynchronously and integrating seamlessly into larger distributed systems.
+These options make it easy to process requests asynchronously and integrate seamlessly into larger distributed systems.
 
 
 ## Choosing the Right Pattern
@@ -397,4 +444,4 @@ The journey from simple agentic workflows to fully autonomous agents represents
 - **Start with simpler patterns** like Augmented LLM and Prompt Chaining for well-defined tasks where predictability is crucial
 - **Progress to more dynamic patterns** like Parallelization and Orchestrator-Workers as your needs grow more complex
 - **Consider fully autonomous agents** only for open-ended tasks where the benefits of flexibility outweigh the need for strict control
- 
+ 

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-patterns.md

@@ -17,10 +17,10 @@ description: "Get started with Dapr Agents through practical step-by-step exampl
 
 | Scenario                                                                                                                                                                                                                                                                           | What You'll Learn |
 |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|
-| [Hello World](https://github.com/dapr/dapr-agents/tree/main/quickstarts/01-hello-world)<br>A rapid introduction that demonstrates core Dapr Agents concepts through simple, practical examples.                                                                                    | - **Basic LLM Usage**: Simple text generation with OpenAI models <br> - **Creating Agents**: Building agents with custom tools in under 20 lines of code <br> <br> - **Simple Workflows**: Setting up multi-step LLM processes |
+| [Hello World](https://github.com/dapr/dapr-agents/tree/main/quickstarts/01-hello-world)<br>A rapid introduction that demonstrates core Dapr Agents concepts through simple, practical examples.                                                                                    | - **Basic LLM Usage**: Simple text generation with OpenAI models <br> - **Creating Agents**: Building agents with custom tools in under 20 lines of code <br> <br> - **Simple Workflows**: Setting up multi-step LLM processes <br> - **DurableAgent Hosting**: Learn `AgentRunner.run`, `AgentRunner.subscribe`, and `AgentRunner.serve` using the `03_durable_agent_*.py` samples |
 | [LLM Call with Dapr Chat Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_dapr)<br>Explore interaction with Language Models through Dapr Agents' `DaprChatClient`, featuring basic text generation with plain text prompts and templates.             | - **Text Completion**: Generating responses to prompts <br> - **Swapping LLM providers**: Switching LLM backends without application code change <br> - **Resilience**: Setting timeout, retry and circuit-breaking <br> - **PII Obfuscation**: Automatically detect and mask sensitive user information |
 | [LLM Call with OpenAI Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_open_ai)<br>Leverage native LLM client libraries with Dapr Agents using the OpenAI Client for chat completion, audio processing, and embeddings.                               | - **Text Completion**: Generating responses to prompts <br> - **Structured Outputs**: Converting LLM responses to Pydantic objects <br><br> *Note: Other quickstarts for specific clients are available for [Elevenlabs](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_elevenlabs), [Hugging Face](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_hugging_face), and [Nvidia](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_nvidia).* |
-| [Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-agent-tool-call)<br>Build your first AI agent with custom tools by creating a practical weather assistant that fetches information and performs actions.                                            | - **Tool Definition**: Creating reusable tools with the `@tool` decorator <br> - **Agent Configuration**: Setting up agents with roles, goals, and tools <br> - **Function Calling**: Enabling LLMs to execute Python functions |
+| Standalone & Durable Agents <br> [Standalone Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-standalone-agent-tool-call) · [Durable Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-durable-agent-tool-call) | - **Standalone Agents**: Build conversational agents with tools in under 20 lines using the `Agent` class <br> - **Durable Agents**: Upgrade to workflow-backed `DurableAgent` instances with `AgentRunner.run/subscribe/serve` <br> - **Tool Definition**: Reuse tools with the `@tool` decorator and structured args models <br> - **Function Calling**: Let LLMs invoke Python functions safely |
 | [Agentic Workflow](https://github.com/dapr/dapr-agents/tree/main/quickstarts/04-llm-based-workflows)<br>Dive into stateful workflows with Dapr Agents by orchestrating sequential and parallel tasks through powerful workflow capabilities.                                          | - **LLM-powered Tasks**: Using language models in workflows <br> - **Task Chaining**: Creating resilient multi-step processes executing in sequence <br> - **Fan-out/Fan-in**: Executing activities in parallel; then synchronizing these activities until all preceding activities have completed |
 | [Multi-Agent Workflows](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflows)<br>Explore advanced event-driven workflows featuring a Lord of the Rings themed multi-agent system where autonomous agents collaborate to solve problems. | - **Multi-agent Systems**: Creating a network of specialized agents <br> - **Event-driven Architecture**: Implementing pub/sub messaging between agents <br> - **Workflow Orchestration**: Coordinating agents through different selection strategies|
 | [Multi-Agent Workflow on Kubernetes](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflow-k8s)<br>Run multi-agent workflows in Kubernetes, demonstrating deployment and orchestration of event-driven agent systems in a containerized environment.   | - **Kubernetes Deployment**: Running agents on Kubernetes <br> - **Container Orchestration**: Managing agent lifecycles with K8s <br> - **Service Communication**: Inter-agent communication in K8s |

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-quickstarts.md

@@ -32,8 +32,8 @@ metadata:
   name: mycrypto
 spec:
   type: crypto.dapr.localstorage
+  version: v1
   metadata:
-    version: v1
     - name: path
       value: /path/to/folder/
 ```

daprdocs/content/en/reference/components-reference/supported-cryptography/local-storage.md

@@ -275,13 +275,13 @@ module:
       target: assets
     - source: daprdocs/archetypes
       target: archetypes
-    - source: sdkdocs/python/daprdocs/content/en/python-sdk-docs
+    - source: sdkdocs/python/content/en/python-sdk-docs
       target: content/developing-applications/sdks/python
       lang: en
-    - source: sdkdocs/python/daprdocs/content/en/python-sdk-contributing
+    - source: sdkdocs/python/content/en/python-sdk-contributing
       target: content/contributing/sdk-contrib/
       lang: en
-    - source: sdkdocs/php/daprdocs/content/en/php-sdk-docs
+    - source: sdkdocs/php/content/en/php-sdk-docs
       target: content/developing-applications/sdks/php
       lang: en
     - source: sdkdocs/dotnet/content/en/dotnet-sdk-docs
@@ -290,34 +290,34 @@ module:
     - source: sdkdocs/dotnet/content/en/dotnet-sdk-contributing
       target: content/contributing/sdk-contrib/
       lang: en
-    - source: sdkdocs/go/daprdocs/content/en/go-sdk-docs
+    - source: sdkdocs/go/content/en/go-sdk-docs
       target: content/developing-applications/sdks/go
       lang: en
-    - source: sdkdocs/go/daprdocs/content/en/go-sdk-contributing
+    - source: sdkdocs/go/content/en/go-sdk-contributing
       target: content/contributing/sdk-contrib/
       lang: en
-    - source: sdkdocs/java/daprdocs/content/en/java-sdk-docs
+    - source: sdkdocs/java/content/en/java-sdk-docs
       target: content/developing-applications/sdks/java
       lang: en
-    - source: sdkdocs/java/daprdocs/content/en/java-sdk-contributing
+    - source: sdkdocs/java/content/en/java-sdk-contributing
       target: content/contributing/sdk-contrib/
       lang: en
-    - source: sdkdocs/js/daprdocs/content/en/js-sdk-docs
+    - source: sdkdocs/js/content/en/js-sdk-docs
       target: content/developing-applications/sdks/js
       lang: en
-    - source: sdkdocs/js/daprdocs/content/en/js-sdk-contributing
+    - source: sdkdocs/js/content/en/js-sdk-contributing
       target: content/contributing/sdk-contrib/
       lang: en
-    - source: sdkdocs/rust/daprdocs/content/en/rust-sdk-docs
+    - source: sdkdocs/rust/content/en/rust-sdk-docs
       target: content/developing-applications/sdks/rust
       lang: en
-    - source: sdkdocs/rust/daprdocs/content/en/rust-sdk-contributing
+    - source: sdkdocs/rust/content/en/rust-sdk-contributing
       target: content/contributing/sdk-contrib/
       lang: en
     - source: sdkdocs/pluggable-components/dotnet/content/en/dotnet-sdk-docs
       target: content/developing-applications/develop-components/pluggable-components/pluggable-components-sdks/pluggable-components-dotnet
       lang: en
-    - source: sdkdocs/pluggable-components/go/daprdocs/content/en/go-sdk-docs
+    - source: sdkdocs/pluggable-components/go/content/en/go-sdk-docs
       target: content/developing-applications/develop-components/pluggable-components/pluggable-components-sdks/pluggable-components-go
       lang: en
     - source: translations/docs-zh/translated_content/zh_CN/docs

hugo.yaml

@@ -66,26 +66,14 @@ Put the Dapr .NET SDK to the test. Walk through the .NET quickstarts and tutoria
 Learn more about local development options, best practices, or browse NuGet packages to add to your existing .NET 
 applications.
 
-<div class="card-deck">
-  <div class="card">
-    <div class="card-body">
-      <h5 class="card-title"><b>Development</b></h5>
-      <p class="card-text">Learn about local development integration options</p>
-      <a href="{{% ref dotnet-integrations %}}" class="stretched-link"></a>
-    </div>
-  <div class="card">
-    <div class="card-body">
-      <h5 class="card-title"><b>Best Practices</b></h5>
-      <p class="card-text">Learn about best practices for developing .NET Dapr applications</p>
-      <a href="{{% ref dotnet-guidance %}}" class="stretched-link"></a>
-    </div>
-  </div>
-  <div class="card">
-    <div class="card-body">
-      <h5 class="card-title"><b>NuGet packages</b></h5>
-      <p class="card-text">NuGet packages for adding the Dapr to your .NET applications.</p>
-      <a href="https://www.nuget.org/profiles/dapr.io" class="stretched-link"></a>
-    </div>
-  </div>
-</div>
-<br />
+{{% cardpane %}}
+{{% card title="**Development**"%}}
+  [Learn about local development integration options]({{% ref dotnet-integrations %}})
+{{% /card %}}
+{{% card title="**Best Practices**"%}}
+  [Learn about best practices for developing .NET Dapr applications]({{% ref dotnet-guidance %}})
+{{% /card %}}
+{{% card title="**Nuget Packages**"%}}
+  [NuGet packages for adding the Dapr to your .NET applications](https://www.nuget.org/profiles/dapr.io)
+{{% /card %}}
+{{% /cardpane %}}

sdkdocs/dotnet/content/en/dotnet-sdk-docs/_index.md

@@ -2,7 +2,7 @@
 type: docs
 title: "Dapr actors .NET SDK"
 linkTitle: "Actors"
-weight: 30000
+weight: 40000
 description: Get up and running with the Dapr actors .NET SDK
 ---