diff --git a/docs/develop/go/integrations/google-adk.mdx b/docs/develop/go/integrations/google-adk.mdx
index 7c9de58607..071880461b 100644
--- a/docs/develop/go/integrations/google-adk.mdx
+++ b/docs/develop/go/integrations/google-adk.mdx
@@ -56,7 +56,7 @@ go get go.temporal.io/googleadk@latest
import "go.temporal.io/googleadk"
```
-The source and releases are maintained in
+The module is versioned separately from the Temporal Go SDK. Its source and releases are maintained in
[`temporalio/ai-integrations`](https://github.com/temporalio/ai-integrations/tree/main/go/googleadk).
## Run an agent with Durable Execution
diff --git a/docs/develop/java/integrations/spring-ai.mdx b/docs/develop/java/integrations/spring-ai.mdx
index d309c84603..667909462f 100644
--- a/docs/develop/java/integrations/spring-ai.mdx
+++ b/docs/develop/java/integrations/spring-ai.mdx
@@ -8,53 +8,49 @@ tags:
- Spring AI
- Integrations
- AI Frameworks
-description: Build durable AI agents in Java with the Temporal Spring AI integration.
+description: Run Spring AI agents on Temporal with durable model calls, Activity tools, and replay-safe orchestration using Spring Boot.
---
import { ReleaseNoteHeader } from '@site/src/components';
[Spring AI](https://docs.spring.io/spring-ai/reference/) is an agent framework for Java applications — chat clients, tool calling, vector stores, embeddings, and MCP servers, all wired through Spring Boot.
-The [Temporal Spring AI integration](https://central.sonatype.com/artifact/io.temporal/temporal-spring-ai) makes Spring AI agents durable: model calls run through Temporal Activities recorded in Event history, and tools are dispatched per their type so each kind lands in the right place in Workflow execution — Activity stubs and Nexus stubs as durable operations, `@SideEffectTool` classes wrapped in `Workflow.sideEffect`, and plain tools running directly in Workflow code. Agents retry on failure and replay deterministically without changing how you write Spring AI code.
+The [Temporal Spring AI integration](https://central.sonatype.com/artifact/io.temporal/spring-ai) makes Spring AI agents durable: model calls run through Temporal Activities recorded in Event history, and tools are dispatched per their type so each kind lands in the right place in Workflow execution — Activity stubs and Nexus stubs as durable operations, `@SideEffectTool` classes wrapped in `Workflow.sideEffect`, and plain tools running directly in Workflow code. Agents retry on failure and replay deterministically without changing how you write Spring AI code.
-The integration is built on the Temporal Java SDK's [Plugin system](/develop/plugins-guide) and is distributed as the `io.temporal:temporal-spring-ai` module alongside the existing [Spring Boot integration](/develop/java/integrations/spring-boot-integration).
+The integration is built on the Temporal Java SDK's [Plugin system](/develop/plugins-guide) and is distributed as the standalone `io.temporal:spring-ai` module alongside the existing [Spring Boot integration](/develop/java/integrations/spring-boot-integration).
## Prerequisites
-The integration requires all of the following on your application's classpath. The plugin won't auto-configure if any of these are missing or below the listed minimum:
+Your application needs a Java runtime, with Spring Boot, Spring AI, and the Temporal Java SDK on its classpath. Refer to the [integration's compatibility requirements](https://github.com/temporalio/ai-integrations/tree/main/java/spring-ai#requirements-and-installation) for supported versions.
-| Dependency | Minimum version |
-| ----------------- | --------------- |
-| Java | 17 |
-| Spring Boot | 3.x |
-| Spring AI | 1.1.0 |
-| Temporal Java SDK | 1.35.0 |
-
-You also need the [`temporal-spring-boot-starter`](/develop/java/integrations/spring-boot-integration) and a Spring AI model starter (for example, `spring-ai-starter-model-openai`) — `temporal-spring-ai` does not pull in a model provider on its own.
+You also need the [`temporal-spring-boot-starter`](/develop/java/integrations/spring-boot-integration) and a Spring AI model starter (for example, `spring-ai-starter-model-openai`). The integration does not pull in a model provider on its own.
## Add the dependency
-Add `temporal-spring-ai` alongside `temporal-spring-boot-starter` and a Spring AI model starter (for example, `spring-ai-starter-model-openai`).
+Add `io.temporal:spring-ai` alongside `temporal-spring-boot-starter` and a Spring AI model starter (for example, `spring-ai-starter-model-openai`). The Spring AI integration is versioned separately from the Temporal Java SDK.
+
+Choose a compatible [release from Maven Central](https://central.sonatype.com/artifact/io.temporal/spring-ai).
+Set `temporal-spring-ai.version` in Maven or `temporalSpringAiVersion` in Gradle to that version.
**[Apache Maven](https://maven.apache.org/):**
```xml
io.temporal
- temporal-spring-ai
- ${temporal-sdk.version}
+ spring-ai
+ ${temporal-spring-ai.version}
```
**[Gradle Groovy DSL](https://gradle.org/):**
```groovy
-implementation "io.temporal:temporal-spring-ai:${temporalSdkVersion}"
+implementation "io.temporal:spring-ai:${temporalSpringAiVersion}"
```
-When `temporal-spring-ai` is on the classpath, the `SpringAiPlugin` auto-registers `ChatModelActivity` with all Temporal Workers created by the Spring Boot integration. Optional Activities are auto-configured when their dependencies are present:
+When `io.temporal:spring-ai` is on the classpath, the `SpringAiPlugin` auto-registers `ChatModelActivity` with all Temporal Workers created by the Spring Boot integration. Optional Activities are auto-configured when their dependencies are present:
| Feature | Dependency | Registered Activity |
| ------------ | --------------- | ------------------------ |
@@ -62,6 +58,17 @@ When `temporal-spring-ai` is on the classpath, the `SpringAiPlugin` auto-registe
| Embeddings | `spring-ai-rag` | `EmbeddingModelActivity` |
| MCP | `spring-ai-mcp` | `McpClientActivity` |
+### Migrate from the previous package
+
+When moving from `io.temporal:temporal-spring-ai`, follow the
+[migration guide](https://github.com/temporalio/ai-integrations/tree/main/java/spring-ai#moving-from-spring-ai-1)
+to align your application's Spring AI and Spring Boot BOMs.
+
+Pass option builders to `ChatClient`, such as `.defaultOptions(OpenAiChatOptions.builder().reasoningEffort("high"))`, or call `.mutate()` on existing options.
+
+Complete existing Workflow Executions before switching, or keep them on separate Worker deployments. Workflow histories
+created with `io.temporal:temporal-spring-ai` are incompatible with `io.temporal:spring-ai`.
+
## Call a chat model from a Workflow
Use `ActivityChatModel` as a Spring AI `ChatModel` inside a Workflow. Every call goes through a Temporal Activity, so model responses are durable and retried per your Activity options.
@@ -104,12 +111,16 @@ public ChatWorkflowImpl(String systemPrompt) {
// - Activity stubs (weatherTool) become durable AI tools
// - plain workflow tool classes (stringTools) execute directly in workflow
// - @SideEffectTool classes (timestampTools) are wrapped in sideEffect()
- // - PromptChatMemoryAdvisor maintains conversation history
+ // - MessageChatMemoryAdvisor maintains conversation history
this.chatClient =
TemporalChatClient.builder(activityChatModel)
.defaultSystem(systemPrompt)
.defaultTools(weatherTool, stringTools, timestampTools)
- .defaultAdvisors(PromptChatMemoryAdvisor.builder(chatMemory).build())
+ .defaultAdvisors(
+ advisors ->
+ advisors
+ .advisors(MessageChatMemoryAdvisor.builder(chatMemory).build())
+ .param(ChatMemory.CONVERSATION_ID, Workflow.getInfo().getWorkflowId()))
.build();
}
@@ -333,6 +344,18 @@ Keys that neither match a registered `ChatModel` bean nor equal `"default"` caus
`ActivityMcpClient.create()` and `create(ActivityOptions)` work the same way for MCP tool calls, with a 30-second default timeout.
+### Disable provider retries
+
+Disable the provider SDK's retries so each Temporal Activity attempt makes one provider request. For the Spring Boot OpenAI chat model, set:
+
+```properties
+spring.ai.openai.chat.max-retries=0
+```
+
+For manually constructed OpenAI or Anthropic models, set `.maxRetries(0)` on the provider options before building the Worker's model. Setting retries on a Workflow prompt does not reconfigure an existing provider client.
+
+OpenAI HTTP failures retain their native exception types. The integration classifies retryable failures and honors provider retry delays; see the [provider retry reference](https://github.com/temporalio/ai-integrations/tree/main/java/spring-ai#provider-retries) for details.
+
## Provider-specific chat options
Provider-specific `ChatOptions` subclasses — for example, `AnthropicChatOptions` to enable extended thinking, or `OpenAiChatOptions` to set `reasoning_effort` — pass through the Activity boundary unchanged. Attach them via `ChatClient.defaultOptions(...)` and the plugin re-applies them on the Activity side before calling the underlying model:
@@ -340,12 +363,8 @@ Provider-specific `ChatOptions` subclasses — for example, `AnthropicChatOption
[springai/multimodel/src/main/java/io/temporal/samples/springai/multimodel/MultiModelWorkflowImpl.java](https://github.com/temporalio/samples-java/blob/main/springai/multimodel/src/main/java/io/temporal/samples/springai/multimodel/MultiModelWorkflowImpl.java)
```java
-AnthropicChatOptions thinkingOptions =
- AnthropicChatOptions.builder()
- .thinking(AnthropicApi.ThinkingType.ENABLED, 1024)
- .temperature(1.0)
- .maxTokens(4096)
- .build();
+AnthropicChatOptions.Builder thinkingOptions =
+ AnthropicChatOptions.builder().thinkingEnabled(1024).temperature(1.0).maxTokens(4096);
chatClients.put(
"think",
TemporalChatClient.builder(anthropicModel)
@@ -358,7 +377,7 @@ chatClients.put(
```
-The pass-through relies on the `ChatOptions` subclass overriding `copy()` to return its own type — every provider class shipped with Spring AI does.
+Spring AI options are immutable. Pass their builder to `defaultOptions(...)`, or call `.mutate()` on an existing options object. The integration preserves provider-specific fields across the Activity boundary.
## Media in messages
@@ -387,6 +406,6 @@ new McpPlugin();
## Resources
-- [`temporal-spring-ai` README](https://github.com/temporalio/sdk-java/blob/main/contrib/temporal-spring-ai/README.md) — full reference for the module
+- [Temporal Spring AI README](https://github.com/temporalio/ai-integrations/tree/main/java/spring-ai) — full reference for the standalone module
- [Spring Boot integration](/develop/java/integrations/spring-boot-integration) — required companion module
- [Plugin system](/develop/plugins-guide) — how integrations are registered with Workers and Clients
diff --git a/docs/develop/plugins-guide.mdx b/docs/develop/plugins-guide.mdx
index 6fc5968a85..68a3b33a61 100644
--- a/docs/develop/plugins-guide.mdx
+++ b/docs/develop/plugins-guide.mdx
@@ -38,8 +38,8 @@ If you prefer to learn by getting hands-on with code, check out some existing pl
- Temporal maintains an
[OpenAI Agents SDK](https://github.com/temporalio/ai-integrations/tree/main/python/openai_agents) plugin for Python
-- Temporal's Python SDK ships with a
- [LangGraph](https://github.com/temporalio/sdk-python/tree/main/temporalio/contrib/langgraph) plugin
+- Temporal maintains a
+ [LangGraph](https://github.com/temporalio/ai-integrations/tree/main/python/langgraph) plugin for Python
- [Temporal client and Worker plugin for Pydantic AI](https://github.com/pydantic/pydantic-ai/blob/d9b4b2540183a4426669b2824c87cdfc36144780/pydantic_ai_slim/pydantic_ai/durable_exec/temporal/__init__.py#L142)
- Temporal's TypeScript SDK ships with an
[OpenTelemetry Plugin](https://github.com/temporalio/sdk-typescript/blob/main/contrib/interceptors-opentelemetry/src/plugin.ts)
diff --git a/docs/develop/python/integrations/deepagents.mdx b/docs/develop/python/integrations/deepagents.mdx
index 6fe322857f..34c5d97ab6 100644
--- a/docs/develop/python/integrations/deepagents.mdx
+++ b/docs/develop/python/integrations/deepagents.mdx
@@ -31,7 +31,6 @@ samples for the complete code.
## Prerequisites
-- Python 3.11 or newer.
- This guide assumes you are already familiar with Deep Agents. If you aren't, refer to the
[Deep Agents documentation](https://github.com/langchain-ai/deepagents) for more details.
- If you are new to Temporal, we recommend reading [Understanding Temporal](/evaluate/understanding-temporal) or taking
@@ -42,19 +41,23 @@ samples for the complete code.
## Install the plugin
-Install the Temporal Python SDK with Deep Agents support:
+Install the standalone `temporalio-deepagents` package:
```bash
-uv add "temporalio[deepagents]>=1.32.0"
+uv add temporalio-deepagents
```
or with pip:
```bash
-pip install "temporalio[deepagents]>=1.32.0"
+pip install temporalio-deepagents
```
-Requires Python 3.11 or newer, the same floor that `deepagents` sets.
+The package installs the Temporal Python SDK and Deep Agents dependencies. Refer to the
+[package requirements](https://github.com/temporalio/ai-integrations/blob/main/python/deepagents/pyproject.toml)
+for supported Python and dependency versions.
+
+Import `DeepAgentsPlugin`, `TemporalBackend`, and other integration helpers from `temporalio.deepagents`.
## Hello world
@@ -525,7 +528,7 @@ class StreamingWorkflow:
## Compose with an observability plugin
This plugin carries no tracing context of its own. For observability, compose it with an observability plugin such as
-[`temporalio.contrib.langsmith`](https://github.com/temporalio/sdk-python/tree/main/temporalio/contrib/langsmith) or
+[`temporalio.langsmith`](/develop/python/integrations/langsmith) or
`temporalio.contrib.opentelemetry`. Registration order of the two plugins does not matter; the observability plugin
captures the LLM calls that `DeepAgentsPlugin` runs as Activities. The Workflow itself is an ordinary Deep Agent — the tracing
comes entirely from composing the plugins on the Client.
diff --git a/docs/develop/python/integrations/google-adk.mdx b/docs/develop/python/integrations/google-adk.mdx
index 4da9b14039..1f4acb0e07 100644
--- a/docs/develop/python/integrations/google-adk.mdx
+++ b/docs/develop/python/integrations/google-adk.mdx
@@ -40,18 +40,25 @@ import { ReleaseNoteHeader } from '@site/src/components';
## Install
-Make sure you have the Temporal Python SDK (requires version 1.28.0 or later). Then install the `google-adk`:
+Install the standalone `temporalio-google-adk` package:
```bash
-uv add "temporalio[google-adk]>=1.28.0"
+uv add temporalio-google-adk
```
If you use pip:
```bash
-pip install "temporalio[google-adk]>=1.28.0"
+pip install temporalio-google-adk
```
+The package installs the Temporal Python SDK and Google ADK dependencies. Refer to the
+[package requirements](https://github.com/temporalio/ai-integrations/blob/main/python/google_adk/pyproject.toml)
+for supported Python and dependency versions.
+
+Import `GoogleAdkPlugin` and `TemporalModel` from `temporalio.google_adk`. Import Workflow helpers such as `activity_as_tool`
+from `temporalio.google_adk.workflow`.
+
## Define an agent in a Workflow
Write your agent the way you normally would with the ADK. The one Temporal-specific piece is `TemporalModel`, which you
@@ -266,6 +273,12 @@ which agent ran and when.
## Use MCP tool servers
+Install the package's `mcp` extra:
+
+```bash
+uv add "temporalio-google-adk[mcp]"
+```
+
To give an agent tools from an [MCP](https://modelcontextprotocol.io/) server, use `TemporalMcpToolSet`. It runs the
server's list-tools and call-tool operations as Activities because connecting to an MCP server is external I/O. You define a factory function for the toolset and register it with the plugin
through a `TemporalMcpToolSetProvider`.
diff --git a/docs/develop/python/integrations/google-genai.mdx b/docs/develop/python/integrations/google-genai.mdx
index 7b5300f4ab..2bfdf0c65d 100644
--- a/docs/develop/python/integrations/google-genai.mdx
+++ b/docs/develop/python/integrations/google-genai.mdx
@@ -46,19 +46,24 @@ samples for the complete code.
## Install the plugin
-Install the Temporal Python SDK with Google GenAI support (requires `temporalio` 1.31.0 or later):
+Install the standalone `temporalio-google-genai` package:
```bash
-uv add "temporalio[google-genai]>=1.31.0"
+uv add temporalio-google-genai
```
If you use pip:
```bash
-pip install "temporalio[google-genai]>=1.31.0"
+pip install temporalio-google-genai
```
-The [MCP](#use-mcp-tool-servers) path also needs the `mcp` package, which the extra does not install.
+The package installs the Temporal Python SDK and Google GenAI dependencies. Refer to the
+[package requirements](https://github.com/temporalio/ai-integrations/blob/main/python/google_genai/pyproject.toml)
+for supported Python and dependency versions.
+
+Import `GoogleGenAIPlugin`, `TemporalAsyncClient`, and `TemporalMcpClientSession` from `temporalio.google_genai`.
+For [MCP tool servers](#use-mcp-tool-servers), install the package's `mcp` extra.
## Call a model from a Workflow
@@ -302,6 +307,12 @@ class StructuredOutputWorkflow:
## Use MCP tool servers
+Install the package's `mcp` extra:
+
+```bash
+uv add "temporalio-google-genai[mcp]"
+```
+
To give a model tools from an [MCP](https://modelcontextprotocol.io/) server, register the server on the Worker and
reference it by name in the Workflow. Connecting to an MCP server is external I/O, so the plugin holds the connection on
the Worker and runs `list_tools` and `call_tool` as Activities against it.
@@ -570,7 +581,7 @@ all of a client's calls with `activity_config`:
from datetime import timedelta
from temporalio.common import RetryPolicy
-from temporalio.contrib.google_genai import TemporalAsyncClient
+from temporalio.google_genai import TemporalAsyncClient
from temporalio.workflow import ActivityConfig
client = TemporalAsyncClient(
diff --git a/docs/develop/python/integrations/index.mdx b/docs/develop/python/integrations/index.mdx
index 688e3d730b..b9cfe1eeca 100644
--- a/docs/develop/python/integrations/index.mdx
+++ b/docs/develop/python/integrations/index.mdx
@@ -17,4 +17,7 @@ Most of these integrations are built on the Temporal Python SDK's [Plugin system
can also use to build your own integrations. A few, such as OpenRouter, are sample patterns that need nothing inside
Workflow code.
+Temporal-maintained AI integrations are distributed as [standalone packages](https://github.com/temporalio/ai-integrations),
+such as `temporalio-strands-agents`. Each integration guide lists its package and import paths.
+
diff --git a/docs/develop/python/integrations/langgraph.mdx b/docs/develop/python/integrations/langgraph.mdx
index a887e407a4..f32c351927 100644
--- a/docs/develop/python/integrations/langgraph.mdx
+++ b/docs/develop/python/integrations/langgraph.mdx
@@ -39,24 +39,28 @@ samples for the complete code.
## Install the plugin
-Install the Temporal Python SDK with LangGraph support (requires `temporalio` 1.27.0 or later):
+Install the standalone `temporalio-langgraph` package:
```bash
-uv add "temporalio[langgraph]"
+uv add temporalio-langgraph
```
or with pip:
```bash
-pip install "temporalio[langgraph]"
+pip install temporalio-langgraph
```
+The package installs the Temporal Python SDK and LangGraph dependencies. Refer to the
+[package requirements](https://github.com/temporalio/ai-integrations/blob/main/python/langgraph/pyproject.toml)
+for supported Python and dependency versions.
+
:::note
-Python 3.11 or newer is required for the Functional API (`@entrypoint` / `@task`), for `interrupt()`, and for streaming
-from a node running in the Workflow. On older Python versions the plugin loads but emits a warning, and those features
-will not work because LangGraph relies on `contextvars` propagation through `asyncio.create_task()`, which is only
-available from Python 3.11 onward.
+Use a Python runtime that supports the `context` parameter of
+[`asyncio.create_task()`](https://docs.python.org/3/library/asyncio-task.html#asyncio.create_task) for the Functional API
+(`@entrypoint` / `@task`), `interrupt()`, and streaming from a node running in the Workflow. LangGraph uses this parameter
+to propagate `contextvars`. The plugin warns if your runtime does not support these features.
:::
@@ -73,7 +77,7 @@ from datetime import timedelta
from langgraph.graph import START, StateGraph
from temporalio import workflow
-from temporalio.contrib.langgraph import graph
+from temporalio.langgraph import graph
async def process_query(query: str) -> str:
@@ -111,7 +115,7 @@ Create a `LangGraphPlugin` with your graphs and pass it to the Worker:
import asyncio
from temporalio.client import Client
-from temporalio.contrib.langgraph import LangGraphPlugin
+from temporalio.langgraph import LangGraphPlugin
from temporalio.worker import Worker
@@ -190,7 +194,7 @@ from datetime import timedelta
from langgraph.func import entrypoint as lg_entrypoint
from langgraph.func import task
from temporalio import workflow
-from temporalio.contrib.langgraph import entrypoint
+from temporalio.langgraph import entrypoint
@task
@@ -241,7 +245,7 @@ class ReactAgentWorkflow:
### Configure the Worker with the Functional API
```python
-from temporalio.contrib.langgraph import LangGraphPlugin
+from temporalio.langgraph import LangGraphPlugin
plugin = LangGraphPlugin(
entrypoints={"react-agent": react_agent},
@@ -279,7 +283,7 @@ from `runtime.context`:
from langgraph.runtime import Runtime
from typing_extensions import TypedDict
-from temporalio.contrib.langgraph import graph
+from temporalio.langgraph import graph
class Context(TypedDict):
@@ -309,7 +313,7 @@ or `entrypoint(name, cache=...)` in the new run to skip re-executing nodes that
```python
from temporalio import workflow
-from temporalio.contrib.langgraph import cache, graph
+from temporalio.langgraph import cache, graph
@workflow.defn
@@ -344,7 +348,7 @@ from langgraph.graph import START, StateGraph
from typing_extensions import TypedDict
from temporalio import workflow
-from temporalio.contrib.langgraph import LangGraphPlugin, graph
+from temporalio.langgraph import LangGraphPlugin, graph
from temporalio.contrib.workflow_streams import WorkflowStream, WorkflowStreamClient
@@ -405,9 +409,8 @@ print(await handle.result())
:::note
-Streaming from a node running in the Workflow (`execute_in: "workflow"`) requires Python
-3.11 or newer, because LangGraph relies on `contextvars` propagation through
-`asyncio.create_task()`. See the [installation note](#install-the-plugin) above.
+For streaming from a node running in the Workflow (`execute_in: "workflow"`), check the Python runtime requirements
+in the [installation note](#install-the-plugin).
:::
@@ -451,7 +454,7 @@ For a complete working example, see the
## Tracing
For tracing your LangGraph Workflows and Activities, we recommend the
-[Temporal LangSmith plugin](https://github.com/temporalio/sdk-python/tree/main/temporalio/contrib/langsmith). It
+[Temporal LangSmith plugin](/develop/python/integrations/langsmith). It
composes with `LangGraphPlugin` — pass both plugins to your Worker.
## Stores are not supported
diff --git a/docs/develop/python/integrations/langsmith.mdx b/docs/develop/python/integrations/langsmith.mdx
index 38d3123eff..9869d81490 100644
--- a/docs/develop/python/integrations/langsmith.mdx
+++ b/docs/develop/python/integrations/langsmith.mdx
@@ -47,17 +47,19 @@ LangSmith, add the `LangSmithPlugin` to your Worker.
Follow the steps below to configure your Worker.
-1. Install the Temporal Python SDK with the LangSmith extra.
+1. Install the standalone `temporalio-langsmith` package. It installs the Temporal Python SDK and LangSmith dependencies.
+ Refer to the [package requirements](https://github.com/temporalio/ai-integrations/blob/main/python/langsmith/pyproject.toml)
+ for supported Python and dependency versions.
```bash
- uv add "temporalio[langsmith]>=1.26.0"
+ uv add temporalio-langsmith
```
2. Add the `LangSmithPlugin` to your Worker. Set `project_name` to the LangSmith project where you want traces to
appear.
```python
- from temporalio.contrib.langsmith import LangSmithPlugin
+ from temporalio.langsmith import LangSmithPlugin
from temporalio.worker import Worker
worker = Worker(
@@ -86,7 +88,7 @@ Workflows they trigger.
```python
from temporalio.client import Client
-from temporalio.contrib.langsmith import LangSmithPlugin
+from temporalio.langsmith import LangSmithPlugin
client = await Client.connect(
"localhost:7233",
diff --git a/docs/develop/python/integrations/strands-agents.mdx b/docs/develop/python/integrations/strands-agents.mdx
index e21edf6f8f..cb83428f5c 100644
--- a/docs/develop/python/integrations/strands-agents.mdx
+++ b/docs/develop/python/integrations/strands-agents.mdx
@@ -39,18 +39,25 @@ Install the plugin, then run a minimal Strands agent inside a Temporal Workflow.
### Install the plugin
-Install the Temporal Python SDK with Strands Agents support (requires `temporalio` 1.28.0 or later):
+Install the standalone `temporalio-strands-agents` package:
```bash
-uv add "temporalio[strands-agents]"
+uv add temporalio-strands-agents
```
or with pip:
```bash
-pip install "temporalio[strands-agents]"
+pip install temporalio-strands-agents
```
+The package installs the Temporal Python SDK and Strands Agents dependencies. Refer to the
+[package requirements](https://github.com/temporalio/ai-integrations/blob/main/python/strands_agents/pyproject.toml)
+for supported Python and dependency versions.
+
+Import `StrandsPlugin`, `TemporalAgent`, and `TemporalMCPClient` from `temporalio.strands_agents`. Import Workflow helpers
+such as `activity_as_tool` and `activity_as_hook` from `temporalio.strands_agents.workflow`.
+
### Run a Strands agent with Durable Execution
The following example runs a Strands agent inside a Temporal Workflow. Model calls execute as Temporal Activities, which
@@ -875,7 +882,7 @@ To get distributed traces across model, tool, and MCP Activities, combine `Stran
import opentelemetry.trace
from temporalio.client import Client
from temporalio.contrib.opentelemetry import OpenTelemetryPlugin, create_tracer_provider
-from temporalio.contrib.strands import StrandsPlugin
+from temporalio.strands_agents import StrandsPlugin
from temporalio.worker import Worker
diff --git a/docs/develop/typescript/integrations/ai-sdk.mdx b/docs/develop/typescript/integrations/ai-sdk.mdx
index 32ca71e092..db5bf2a5d3 100644
--- a/docs/develop/typescript/integrations/ai-sdk.mdx
+++ b/docs/develop/typescript/integrations/ai-sdk.mdx
@@ -7,34 +7,33 @@ tags:
- AI SDK
- TypeScript SDK
- Temporal SDKs
-description: Implement AI applications in TypeScript using the Temporal TypeScript SDK and the AI SDK.
+description: Run Vercel AI SDK agents in Temporal Workflows with durable model calls, tools, MCP requests, and streamed responses in TypeScript.
---
-import { ReleaseNoteHeader } from '@site/src/components';
-
Temporal's integration with [Vercel's AI SDK](https://ai-sdk.dev/) lets you use the AI SDK's API directly in Workflow
code while Temporal handles Durable Execution.
Like all API calls, LLM API calls are non-deterministic. In a [Temporal Application](/glossary#temporal-application),
that means you cannot make LLM calls directly from a [Workflow](/glossary#workflow); they must run as
[Activities](/glossary#activity). The AI SDK plugin handles this automatically: when you call methods in the AI SDK such
-as `generateText()`, `streamText()`, or `streamObject()`, the plugin wraps those calls in Activities behind the scenes.
+as `generateText()` or `streamText()`, the plugin wraps those calls in Activities behind the scenes.
This preserves the Vercel AI SDK's developer experience that you are already familiar with while Temporal handles
Durable Execution for you.
:::note
-Import the plugin (`AiSdkPlugin`) from `@temporalio/ai-sdk` in your Worker setup, but import Workflow-side helpers such
-as `temporalProvider` and `TemporalMCPClient` from the `@temporalio/ai-sdk/workflow` subpath. The `/workflow` subpath is
+Import the plugin (`AiSdkPlugin`) from `@temporalio/vercel-ai-sdk` in your Worker setup. Import Workflow-side helpers
+such as `temporalProvider` and `TemporalMCPClient` from `@temporalio/vercel-ai-sdk/workflow`. The `/workflow` subpath is
safe to use in the deterministic Workflow sandbox.
:::
All code snippets in this guide are taken from the TypeScript SDK
-[ai-sdk samples](https://github.com/temporalio/samples-typescript/tree/main/ai-sdk). Refer to the samples for the
+[Vercel AI SDK samples](https://github.com/temporalio/samples-typescript/tree/main/vercel-ai-sdk). Refer to the samples for the
complete code and run them locally.
-
+The standalone integration is maintained in
+[`temporalio/ai-integrations`](https://github.com/temporalio/ai-integrations/tree/main/typescript/vercel-ai-sdk).
## Prerequisites
@@ -46,6 +45,8 @@ complete code and run them locally.
- Ensure you have set up your local development environment by following the
[Set up a local development environment with the TypeScript SDK](/develop/typescript/set-up-your-local-typescript) guide. When you are
done, leave the Temporal Development Server running if you want to test your code locally.
+- Use Node.js, Temporal SDK, and Vercel AI SDK versions that satisfy the integration's
+ [package requirements](https://github.com/temporalio/ai-integrations/blob/main/typescript/vercel-ai-sdk/package.json).
## Configure Workers to use the AI SDK
@@ -55,17 +56,18 @@ the Vercel AI SDK, you need to create a Worker and configure it to use the AI SD
Follow the steps below to configure your Worker.
-1. Install the `@temporalio/ai-sdk` package.
+1. Install the standalone [`@temporalio/vercel-ai-sdk`](https://www.npmjs.com/package/@temporalio/vercel-ai-sdk) package.
+ The integration is versioned separately from the Temporal TypeScript SDK.
```bash
- npm install @temporalio/ai-sdk
+ npm install @temporalio/vercel-ai-sdk
```
2. Create a `worker.ts` file and configure the Worker to use the AI SDK plugin.
```ts {9-11}
import { openai } from '@ai-sdk/openai';
- import { AiSdkPlugin } from '@temporalio/ai-sdk';
+ import { AiSdkPlugin } from '@temporalio/vercel-ai-sdk';
//... other import statements, initializing a connection
// to the Temporal Service to be used by the Worker
@@ -78,7 +80,7 @@ Follow the steps below to configure your Worker.
],
connection,
namespace: 'default',
- taskQueue: 'ai-sdk',
+ taskQueue: 'vercel-ai-sdk',
workflowsPath: require.resolve('./workflows'),
activities,
});
@@ -87,10 +89,10 @@ Follow the steps below to configure your Worker.
```
The `modelProvider` specifies which AI provider to use when creating models. Choose the provider that best suits your
- needs. In the Worker options, you are also specifying that the Worker polls the `ai-sdk` Task Queue for work in the
+ needs. In the Worker options, you are also specifying that the Worker polls the `vercel-ai-sdk` Task Queue for work in the
`default` Namespace. Make sure that you configure your Client application to use the same Task Queue and Namespace.
-3. Run the Worker. This Worker will now poll the Temporal Service for work on the `ai-sdk` Task Queue in the `default`
+3. Run the Worker. This Worker will now poll the Temporal Service for work on the `vercel-ai-sdk` Task Queue in the `default`
Namespace until you stop it.
```bash
@@ -108,7 +110,7 @@ Follow the steps below to configure your Worker.
:::
-See the full example at [ai-sdk samples](https://github.com/temporalio/samples-typescript/tree/main/ai-sdk).
+See the full example at [Vercel AI SDK samples](https://github.com/temporalio/samples-typescript/tree/main/vercel-ai-sdk).
## Develop a simple haiku agent
@@ -136,7 +138,7 @@ to your configured `modelProvider` to create the model.
```ts {2,6}
import { generateText } from 'ai';
-import { temporalProvider } from '@temporalio/ai-sdk/workflow';
+import { temporalProvider } from '@temporalio/vercel-ai-sdk/workflow';
export async function haikuAgent(prompt: string): Promise {
const result = await generateText({
@@ -161,7 +163,7 @@ For example, if you want to call an external API to get the weather, you would i
from the tool function. The following is an example of an Activity that gets the weather for a given location:
-[ai-sdk/src/activities.ts](https://github.com/temporalio/samples-typescript/blob/main/ai-sdk/src/activities.ts)
+[vercel-ai-sdk/src/activities.ts](https://github.com/temporalio/samples-typescript/blob/main/vercel-ai-sdk/src/activities.ts)
```ts
export async function getWeather(input: {
location: string;
@@ -181,7 +183,7 @@ the tool when needed.
```ts {15-23}
import { proxyActivities } from '@temporalio/workflow';
import { generateText, tool } from 'ai';
-import { temporalProvider } from '@temporalio/ai-sdk/workflow';
+import { temporalProvider } from '@temporalio/vercel-ai-sdk/workflow';
import { z } from 'zod';
const { getWeather } = proxyActivities({
@@ -217,11 +219,11 @@ built-in implementation of a stateless MCP client that you can use inside Workfl
Follow the steps below to integrate your agent with an MCP server.
-1. Create a connection to the MCP servers using the `experimental_createMCPClient` function from the `@ai-sdk/mcp`
+1. Create a connection to the MCP servers using the `createMCPClient` function from the `@ai-sdk/mcp`
package. You can register multiple MCP servers by providing multiple factory functions in `mcpClientFactories`.
```ts
- import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
+ import { createMCPClient } from '@ai-sdk/mcp';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
const mcpClientFactories = {
@@ -241,22 +243,22 @@ Follow the steps below to integrate your agent with an MCP server.
2. Configure the Worker to use the MCP client factories.
- ```ts {5}
+ ```ts {6}
const worker = await Worker.create({
+ // ... other Worker options
plugins: [
new AiSdkPlugin({
modelProvider: openai,
- mcpClientFactories
+ mcpClientFactories,
}),
- ]},
- ...
- );
+ ],
+ });
```
3. In your agent Workflow, use `TemporalMCPClient` to get tools from the MCP server by referencing it by name:
```ts {4-5,9}
- import { TemporalMCPClient, temporalProvider } from '@temporalio/ai-sdk/workflow';
+ import { TemporalMCPClient, temporalProvider } from '@temporalio/vercel-ai-sdk/workflow';
export async function mcpAgent(prompt: string): Promise {
const mcpClient = new TemporalMCPClient({ name: 'testServer' });
@@ -277,15 +279,15 @@ Follow the steps below to integrate your agent with an MCP server.
## Stream model output from a Workflow
-The AI SDK's `streamText()` and `streamObject()` functions stream a response incrementally instead of returning it all
-at once. The plugin runs the model call in an Activity and publishes each delta onto a
+The AI SDK's `streamText()` function streams a response incrementally instead of returning it all at once.
+The plugin runs the model call in an Activity and publishes each delta onto a
[Workflow Stream](/develop/typescript/workflows/workflow-streams) topic. External consumers can subscribe to that topic
by Workflow ID to render tokens live as they arrive, while the Workflow durably reassembles the final result.
:::note
Inside the Workflow, the streamed result is reassembled after the Activity completes, so the Workflow's own `textStream`
-/ `partialObjectStream` is not incremental. Live, token-by-token deltas are delivered to **external** consumers through
+/ `partialOutputStream` is not incremental. Live, token-by-token deltas are delivered to **external** consumers through
a `WorkflowStreamClient`. This is inherent to Durable Execution: the Activity must run to completion before the Workflow
can observe a deterministic, replayable result.
@@ -303,7 +305,7 @@ published to), host a `WorkflowStream` in your Workflow, and consume the AI SDK
```ts
import { streamText } from 'ai';
-import { TemporalProvider } from '@temporalio/ai-sdk/workflow';
+import { TemporalProvider } from '@temporalio/vercel-ai-sdk/workflow';
import { WorkflowStream } from '@temporalio/workflow-streams/workflow';
export const STREAM_TOPIC = 'text-stream';
@@ -314,7 +316,7 @@ const streamingProvider = new TemporalProvider({
```
-[ai-sdk/src/workflows.ts](https://github.com/temporalio/samples-typescript/blob/main/ai-sdk/src/workflows.ts)
+[vercel-ai-sdk/src/workflows.ts](https://github.com/temporalio/samples-typescript/blob/main/vercel-ai-sdk/src/workflows.ts)
```ts
export async function streamingAgent(prompt: string): Promise {
// Host the WorkflowStream as the first statement of the workflow so its
@@ -358,7 +360,7 @@ The consumer subscribes to the topic by Workflow ID and renders each delta as it
JSON-encoded AI SDK stream part:
-[ai-sdk/src/client.ts](https://github.com/temporalio/samples-typescript/blob/main/ai-sdk/src/client.ts)
+[vercel-ai-sdk/src/client.ts](https://github.com/temporalio/samples-typescript/blob/main/vercel-ai-sdk/src/client.ts)
```ts
// Subscribe to a Workflow's stream topic and render each text delta live as it
// is published by the streaming activity. Each item's payload is the
@@ -380,44 +382,11 @@ async function renderStream(client: Client, workflowId: string, topic: string):
### Stream structured output
-`streamObject()` streams a structured object as its JSON is generated. It flows through the same model path as
-`streamText()`, so no extra wiring is needed beyond choosing a distinct `streamingTopic` so concurrent streams stay
-separable. External subscribers see the object build up incrementally, and the Workflow durably resolves the final,
-validated object.
-
-
-
-[ai-sdk/src/workflows.ts](https://github.com/temporalio/samples-typescript/blob/main/ai-sdk/src/workflows.ts)
-
-```ts
-export async function streamObjectAgent(prompt: string): Promise {
- new WorkflowStream();
-
- const result = streamObject({
- model: objectStreamingProvider.languageModel('gpt-4o-mini'),
- schema: z.object({
- recipe: z.object({
- name: z.string(),
- ingredients: z.array(z.object({ name: z.string(), amount: z.string() })),
- steps: z.array(z.string()),
- }),
- }),
- prompt,
- });
-
- // External subscribers see the object build up incrementally via the partial
- // JSON deltas published to OBJECT_STREAM_TOPIC. The workflow drains the
- // partial stream and durably resolves the final, validated object.
- for await (const _partial of result.partialObjectStream) {
- // Draining drives the stream; the consumer renders the live partials.
- }
- const object = await result.object;
+Use `streamText()` with `output: Output.object({ schema })` to stream structured output. Choose a distinct
+`streamingTopic` for each concurrent stream. Inside the Workflow, consume `partialOutputStream` and await `result.output`
+for the validated result. External subscribers receive the model deltas through Workflow Streams.
- await sleep('500 milliseconds');
- return object.recipe.name;
-}
-```
-
-
+See the [Vercel AI SDK structured output guide](https://ai-sdk.dev/docs/ai-sdk-core/generating-structured-data#stream-structured-outputs)
+for schemas and output options.
-See the full example at [ai-sdk samples](https://github.com/temporalio/samples-typescript/tree/main/ai-sdk).
+See the full example at [Vercel AI SDK samples](https://github.com/temporalio/samples-typescript/tree/main/vercel-ai-sdk).
diff --git a/docs/develop/typescript/integrations/google-adk-agents.mdx b/docs/develop/typescript/integrations/google-adk-agents.mdx
index 1a3851b21b..7ab6ff2ae5 100644
--- a/docs/develop/typescript/integrations/google-adk-agents.mdx
+++ b/docs/develop/typescript/integrations/google-adk-agents.mdx
@@ -22,9 +22,9 @@ model and routes each model call to an Activity. The integration also provides W
tools, MCP servers, and streamed model responses.
Code snippets on this page come from the
-[Google ADK samples directory](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents).
+[Google ADK samples directory](https://github.com/temporalio/samples-typescript/tree/main/google-adk).
-
+
## Prerequisites
@@ -35,19 +35,25 @@ Code snippets on this page come from the
- Set up your local development environment by following
[Set up a local development environment with the TypeScript SDK](/develop/typescript/set-up-your-local-typescript). Leave the Temporal
development server running to run the samples locally.
-- Install Node.js 22 or later.
+- Use Node.js, Temporal SDK, and Google ADK versions that satisfy the integration's
+ [package requirements](https://github.com/temporalio/ai-integrations/blob/main/typescript/google-adk/package.json).
## Install the Google ADK integration
-Install the [`@temporalio/google-adk-agents`](https://www.npmjs.com/package/@temporalio/google-adk-agents) package. Keep
-all `@temporalio/*` packages in your application on the same version.
+Install the standalone [`@temporalio/google-adk`](https://www.npmjs.com/package/@temporalio/google-adk) package. It is
+versioned separately from the Temporal TypeScript SDK.
```bash
-npm install @temporalio/google-adk-agents
+npm install @temporalio/google-adk
```
-Version 1.23.0 of the integration supports `@google/adk` 1.5.x. The upper bound is required because the Workflow bundle
-uses compatibility shims for that ADK line. Newer ADK versions can fail while bundling the Workflow.
+Keep `@google/adk` within the package's supported peer dependency range. The Workflow bundle uses compatibility shims
+for that range. Install `@modelcontextprotocol/sdk` if you use `TemporalMCPToolset`.
+
+When migrating from `@temporalio/google-adk-agents`, follow the
+[upgrade guidance](https://github.com/temporalio/ai-integrations/tree/main/typescript/google-adk#upgrading-from-adk-15).
+Complete existing Workflow Executions before switching, or keep them on separate Task Queues. The standalone integration
+cannot replay Workflow histories created with `@temporalio/google-adk-agents`.
The Worker reads Gemini credentials from `GOOGLE_GENAI_API_KEY` or `GEMINI_API_KEY`. Credentials remain in the Worker
process. Model requests and responses are Activity inputs and results, so they are stored in Event History. Use a
@@ -63,7 +69,7 @@ Workflow Updates and can query the conversation history.
Create the agent and runner in Workflow code:
-[google-adk-agents/src/agent-chat/workflows.ts](https://github.com/temporalio/samples-typescript/blob/main/google-adk-agents/src/agent-chat/workflows.ts)
+[google-adk/src/agent-chat/workflows.ts](https://github.com/temporalio/samples-typescript/blob/main/google-adk/src/agent-chat/workflows.ts)
```ts
const agent = new LlmAgent({
name: 'assistant',
@@ -77,7 +83,7 @@ const runner = new InMemoryRunner({ agent, appName: 'agent-chat' });
Register `GoogleAdkPlugin` on the Worker to install the model Activities and Workflow bundler configuration:
-[google-adk-agents/src/agent-chat/worker.ts](https://github.com/temporalio/samples-typescript/blob/main/google-adk-agents/src/agent-chat/worker.ts)
+[google-adk/src/agent-chat/worker.ts](https://github.com/temporalio/samples-typescript/blob/main/google-adk/src/agent-chat/worker.ts)
```ts
const worker = await Worker.create({
connection,
@@ -97,16 +103,16 @@ Use each API from its package entry point:
| Entry point | APIs |
| --- | --- |
-| `@temporalio/google-adk-agents` | `GoogleAdkPlugin` for Worker code |
-| `@temporalio/google-adk-agents/workflow` | `TemporalModel`, `TemporalMCPToolset`, and `activityAsTool` for Workflow code |
-| `@temporalio/google-adk-agents/testing` | `fakeModelProvider` and `mockMCPToolset` for tests |
+| `@temporalio/google-adk` | `GoogleAdkPlugin` for Worker code |
+| `@temporalio/google-adk/workflow` | `TemporalModel`, `TemporalMCPToolset`, and `activityAsTool` for Workflow code |
+| `@temporalio/google-adk/testing` | `fakeModelProvider` and `mockMCPToolset` for tests |
-The [agent chat sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents/src/agent-chat)
+The [agent chat sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk/src/agent-chat)
shows this Workflow, Worker, and Client together, including its Update, Query, and Continue-As-New behavior.
An agent graph can delegate work among multiple `LlmAgent` instances. The agents and their transfers remain in the
Workflow, while each `TemporalModel` call runs as an Activity. The
-[multi-agent sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents/src/multi-agent)
+[multi-agent sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk/src/multi-agent)
shows a coordinator transferring a request to a researcher and then a writer.
## Configure model calls
@@ -119,7 +125,7 @@ Set `heartbeatTimeout` to detect a dead Worker and deliver cancellation to a lon
a timer, so a Heartbeat Timeout doesn't detect a stalled call; `startToCloseTimeout` bounds a stalled call.
Use ADK's `outputSchema` to constrain a model response, then validate the result in the Workflow before returning it.
-The [structured-output sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents/src/structured-output)
+The [structured-output sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk/src/structured-output)
shows this pattern for an incident summary.
## Add tools and MCP servers
@@ -130,12 +136,12 @@ performs other I/O must run outside the Workflow.
Use `activityAsTool` to expose an existing Activity to an agent. Its `name` must match an Activity registered in the
Worker's `activities` option. The model's arguments object becomes the Activity's single argument, and the `activity`
-option controls its timeouts and retries. The [tools sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents/src/tools)
+option controls its timeouts and retries. The [tools sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk/src/tools)
shows the Workflow and Worker configuration together.
An ADK `LongRunningFunctionTool` can wait in Workflow code for external input. A Signal can release the tool
asynchronously, while an Update can release it and return an accepted result to the caller. The
-[human-in-the-loop sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents/src/human-in-the-loop)
+[human-in-the-loop sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk/src/human-in-the-loop)
shows both forms of approval.
For MCP, register a named factory with `mcpToolsets: { : factory }` in the Worker plugin, then create a
@@ -143,7 +149,7 @@ For MCP, register a named factory with `mcpToolsets: { : factory }` in the
operation opens a new MCP session, so session state doesn't carry between operations unless the factory returns a
long-lived toolset. MCP failures often have no status and are retryable, so set `activity.retry.maximumAttempts` on the
`TemporalMCPToolset` when retries must be bounded. See the complete Worker and Workflow pair in the
-[MCP sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents/src/mcp).
+[MCP sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk/src/mcp).
## Stream model responses
@@ -156,7 +162,7 @@ The model Activity publishes chunks to the topic and returns the complete respon
is the deterministic value used during replay. Stream delivery is at-least-once, and a retried Activity publishes its
chunks again from the beginning.
-The [streaming sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents/src/streaming)
+The [streaming sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk/src/streaming)
shows how a Workflow publishes chunks and waits for a stream consumer to finish.
## Test and observe your agents
@@ -178,7 +184,7 @@ ADK span attributes can contain prompts and model responses. Send them only to a
sensitive attributes in the span processor. `ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS` doesn't control this behavior in a
Workflow because the Workflow sandbox doesn't expose Worker environment variables.
-The [observability sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents/src/observability)
+The [observability sample](https://github.com/temporalio/samples-typescript/tree/main/google-adk/src/observability)
shows the plugin order and an OpenTelemetry span processor that records model usage.
## Reference and troubleshooting
@@ -203,7 +209,7 @@ first so that ADK's Workflow-side spans bind to its tracer provider. Register `G
Client plugin isn't required.
Custom payload and failure converter modules load before the plugin's polyfills. If either module imports `@google/adk`
-or `@google/genai`, import `@temporalio/google-adk-agents/workflow` first in that module.
+or `@google/genai`, import `@temporalio/google-adk/workflow` first in that module.
### Replay safety
@@ -265,15 +271,15 @@ after the Workflow or handler frame returns. To recover in an ADK `onModelErrorC
`markModelFailureHandled` and return a substitute event created with ADK's `createEvent`. Cancellation can't be handled
this way.
-If a model call fails with a sandbox error such as `fetch is not defined`, check that the agent uses
-`new TemporalModel(...)` instead of a raw model string. A raw model makes ADK attempt the network call inside the
-Workflow instead of routing it to an Activity.
+If a model call fails with a sandbox error such as `fetch is not defined`, use `new TemporalModel(...)` for a custom
+model instance that performs I/O. The plugin routes built-in Gemini and Apigee model strings through `TemporalModel`
+automatically; keep `autoRouteModels` enabled to use that behavior.
## Resources
-- [Google ADK integration package](https://www.npmjs.com/package/@temporalio/google-adk-agents)
-- [Google ADK integration source](https://github.com/temporalio/sdk-typescript/tree/main/contrib/google-adk-agents)
-- [Google ADK samples directory](https://github.com/temporalio/samples-typescript/tree/main/google-adk-agents)
+- [Google ADK integration package](https://www.npmjs.com/package/@temporalio/google-adk)
+- [Google ADK integration source](https://github.com/temporalio/ai-integrations/tree/main/typescript/google-adk)
+- [Google ADK samples directory](https://github.com/temporalio/samples-typescript/tree/main/google-adk)
- [Google ADK source](https://github.com/google/adk-js)
- [Google ADK documentation](https://google.github.io/adk-docs/)
- [Temporal TypeScript SDK documentation](/develop/typescript)
diff --git a/docs/guides/durable-agent-on-agentcore.mdx b/docs/guides/durable-agent-on-agentcore.mdx
index 8be2136941..c880985f55 100644
--- a/docs/guides/durable-agent-on-agentcore.mdx
+++ b/docs/guides/durable-agent-on-agentcore.mdx
@@ -116,7 +116,7 @@ application and Runtime settings. The deployment script generates the AgentCore
## 2. Examine the agent Workflow
The sample creates a
-[`TemporalAgent`](https://github.com/temporalio/sdk-python/blob/main/temporalio/contrib/strands/_temporal_agent.py) with a
+[`TemporalAgent`](/develop/python/integrations/strands-agents) with a
system prompt and the `execute_code` tool: