docs: cleanup from TS scan. Add missing prose and examples. Remove in… (#849)

Author: notowen333

src/content/docs/user-guide/concepts/agents/conversation-management.mdx

@@ -304,9 +304,14 @@ agent = Agent(
 </Tab>
 <Tab label="TypeScript">
 
-```ts
-// Not supported in TypeScript
+Pass a custom `model` to `SummarizingConversationManager` to override the model used for summarization. This enables using a different model, such as a faster or more cost-effective one, without affecting the agent's primary model. Injecting a full `Agent` (with its own tools, hooks, or plugins) for summarization is not currently supported in TypeScript.
+
+```typescript
+--8<-- "user-guide/concepts/agents/conversation-management_imports.ts:summarizing_conversation_manager_advanced_imports"
+
+--8<-- "user-guide/concepts/agents/conversation-management.ts:summarizing_conversation_manager_advanced"
 ```
+
 </Tab>
 </Tabs>
 

src/content/docs/user-guide/concepts/agents/conversation-management.ts

@@ -7,6 +7,7 @@ import {
   SummarizingConversationManager,
   BedrockModel,
 } from '@strands-agents/sdk'
+import { AnthropicModel } from '@strands-agents/sdk/models/anthropic'
 import type { LocalAgent, ConversationManagerReduceOptions } from '@strands-agents/sdk'
 
 async function nullConversationManagerAgent() {
@@ -98,6 +99,27 @@ async function summarizingCustom() {
   // --8<-- [end:summarizing_conversation_manager_custom]
 }
 
+async function summarizingAdvanced() {
+  // --8<-- [start:summarizing_conversation_manager_advanced]
+  // Use a cheaper, faster model for summarization tasks
+  const summarizationModel = new AnthropicModel({
+    modelId: 'claude-haiku-4-5-20251001',
+    maxTokens: 1000,
+    params: { temperature: 0.1 }, // Low temperature for consistent summaries
+  })
+
+  const conversationManager = new SummarizingConversationManager({
+    model: summarizationModel,
+    summaryRatio: 0.4,
+    preserveRecentMessages: 8,
+  })
+
+  const agent = new Agent({
+    conversationManager,
+  })
+  // --8<-- [end:summarizing_conversation_manager_advanced]
+}
+
 async function summarizingSystemPrompt() {
   // --8<-- [start:summarizing_conversation_manager_system_prompt]
   // Custom system prompt for technical conversations

src/content/docs/user-guide/concepts/agents/conversation-management_imports.ts

@@ -38,6 +38,11 @@ import { Agent, SummarizingConversationManager, BedrockModel } from '@strands-ag
 import { Agent, SummarizingConversationManager } from '@strands-agents/sdk'
 // --8<-- [end:summarizing_conversation_manager_system_prompt_imports]
 
+// --8<-- [start:summarizing_conversation_manager_advanced_imports]
+import { Agent, SummarizingConversationManager } from '@strands-agents/sdk'
+import { AnthropicModel } from '@strands-agents/sdk/models/anthropic'
+// --8<-- [end:summarizing_conversation_manager_advanced_imports]
+
 // --8<-- [start:proactive_sliding_window_imports]
 import {
   Agent,

src/content/docs/user-guide/concepts/model-providers/amazon-bedrock.mdx

@@ -883,10 +883,12 @@ Strands allows you to enable and configure reasoning capabilities with your [`Be
 
 ### Structured Output
 
+Amazon Bedrock models support structured output through their tool calling capabilities. Pass a schema to the agent, and Strands converts it to Bedrock's tool specification format and validates the response.
+
 <Tabs>
 <Tab label="Python">
 
-Amazon Bedrock models support structured output through their tool calling capabilities. When you use `Agent.structured_output()`, the Strands SDK converts your schema to Bedrock's tool specification format.
+Define a Pydantic model and pass it to `agent.structured_output()`:
 
 ```python
 from pydantic import BaseModel, Field
@@ -924,12 +926,18 @@ print(f"Rating: {result.rating}")
 </Tab>
 <Tab label="TypeScript">
 
-```ts
-// Structured output is not yet supported in the TypeScript SDK
+Define a Zod schema and pass it as `structuredOutputSchema`. Validated output is on `result.structuredOutput`:
+
+```typescript
+--8<-- "user-guide/concepts/model-providers/amazon-bedrock_imports.ts:structured_output_imports"
+
+--8<-- "user-guide/concepts/model-providers/amazon-bedrock.ts:structured_output"
 ```
 </Tab>
 </Tabs>
 
+For schema patterns, error handling, and per-invocation overrides, see [Structured Output](../agents/structured-output/).
+
 ### Token Counting
 
 Token counting is used by context management strategies to estimate input tokens before each model call.

src/content/docs/user-guide/concepts/model-providers/amazon-bedrock.ts

@@ -12,6 +12,7 @@ import {
   CachePointBlock,
   Message,
 } from '@strands-agents/sdk'
+import { z } from 'zod'
 
 // Basic usage examples
 async function basicUsageDefault() {
@@ -440,3 +441,36 @@ async function requestTimeoutExample() {
 }
 
 void requestTimeoutExample
+
+async function structuredOutputExample() {
+  // --8<-- [start:structured_output]
+  const ProductAnalysis = z.object({
+    name: z.string().describe('Product name'),
+    category: z.string().describe('Product category'),
+    price: z.number().describe('Price in USD'),
+    features: z.array(z.string()).describe('Key product features'),
+    rating: z.number().min(1).max(5).optional().describe('Customer rating 1-5'),
+  })
+
+  const bedrockModel = new BedrockModel()
+  const agent = new Agent({
+    model: bedrockModel,
+    structuredOutputSchema: ProductAnalysis,
+  })
+
+  const result = await agent.invoke(
+    `Analyze this product: The UltraBook Pro is a premium laptop computer
+     priced at $1,299. It features a 15-inch 4K display, 16GB RAM, 512GB SSD,
+     and 12-hour battery life. Customer reviews average 4.5 stars.`
+  )
+
+  const product = result.structuredOutput as z.infer<typeof ProductAnalysis>
+  console.log(`Product: ${product.name}`)
+  console.log(`Category: ${product.category}`)
+  console.log(`Price: $${product.price}`)
+  console.log(`Features: ${product.features.join(', ')}`)
+  console.log(`Rating: ${product.rating}`)
+  // --8<-- [end:structured_output]
+}
+
+void structuredOutputExample

src/content/docs/user-guide/concepts/model-providers/amazon-bedrock_imports.ts

@@ -16,3 +16,9 @@ import { BedrockModel } from '@strands-agents/sdk/models/bedrock'
 // --8<-- [start:request_timeout_imports]
 import { BedrockModel } from '@strands-agents/sdk/models/bedrock'
 // --8<-- [end:request_timeout_imports]
+
+// --8<-- [start:structured_output_imports]
+import { Agent } from '@strands-agents/sdk'
+import { BedrockModel } from '@strands-agents/sdk/models/bedrock'
+import { z } from 'zod'
+// --8<-- [end:structured_output_imports]

src/content/docs/user-guide/concepts/model-providers/anthropic.mdx

@@ -141,6 +141,65 @@ The Python SDK does not currently support passing a pre-configured client. Use `
 </Tab>
 </Tabs>
 
+### Structured Output
+
+Anthropic models support structured output through tool use. Pass a schema to the agent, and Strands generates a tool from it that the model calls to return validated, type-safe data.
+
+<Tabs>
+<Tab label="Python">
+
+Define a Pydantic model and pass it to [`agent.structured_output()`](@api/python/strands.agent.agent#Agent.structured_output):
+
+```python
+from pydantic import BaseModel, Field
+from strands import Agent
+from strands.models.anthropic import AnthropicModel
+
+class MovieReview(BaseModel):
+    """Analyze a movie review."""
+    title: str = Field(description="Movie title")
+    rating: int = Field(description="Rating from 1-10", ge=1, le=10)
+    genre: str = Field(description="Primary genre")
+    sentiment: str = Field(description="Overall sentiment: positive, negative, or neutral")
+    summary: str = Field(description="Brief summary of the review")
+
+model = AnthropicModel(
+    client_args={"api_key": "<KEY>"},
+    max_tokens=1028,
+    model_id="claude-sonnet-4-6",
+)
+
+agent = Agent(model=model)
+
+result = agent.structured_output(
+    MovieReview,
+    """
+    Just watched "The Matrix" - what an incredible sci-fi masterpiece!
+    The groundbreaking visual effects and philosophical themes make this
+    a must-watch. Keanu Reeves delivers a solid performance. 9/10!
+    """
+)
+
+print(f"Movie: {result.title}")
+print(f"Rating: {result.rating}/10")
+print(f"Genre: {result.genre}")
+print(f"Sentiment: {result.sentiment}")
+```
+</Tab>
+<Tab label="TypeScript">
+
+Define a Zod schema and pass it as `structuredOutputSchema`. Validated output is on `result.structuredOutput`:
+
+```typescript
+--8<-- "user-guide/concepts/model-providers/anthropic_imports.ts:structured_output_imports"
+
+--8<-- "user-guide/concepts/model-providers/anthropic.ts:structured_output"
+```
+</Tab>
+</Tabs>
+
+For schema patterns, error handling, and per-invocation overrides, see [Structured Output](../agents/structured-output/).
+
 ### Token Counting
 
 Token counting is used by context management strategies to estimate input tokens before each model call.

src/content/docs/user-guide/concepts/model-providers/anthropic.ts

@@ -6,6 +6,7 @@
 import Anthropic from '@anthropic-ai/sdk'
 import { Agent } from '@strands-agents/sdk'
 import { AnthropicModel } from '@strands-agents/sdk/models/anthropic'
+import { z } from 'zod'
 
 // Basic usage
 async function basicUsage() {
@@ -41,3 +42,38 @@ async function customClient() {
   console.log(response)
   // --8<-- [end:custom_client]
 }
+
+// Structured output
+async function structuredOutputExample() {
+  // --8<-- [start:structured_output]
+  const MovieReview = z.object({
+    title: z.string().describe('Movie title'),
+    rating: z.number().min(1).max(10).describe('Rating from 1-10'),
+    genre: z.string().describe('Primary genre'),
+    sentiment: z.enum(['positive', 'negative', 'neutral']).describe('Overall sentiment'),
+    summary: z.string().describe('Brief summary of the review'),
+  })
+
+  const model = new AnthropicModel({
+    apiKey: '<KEY>',
+    modelId: 'claude-sonnet-4-6',
+    maxTokens: 1028,
+  })
+
+  const agent = new Agent({ model, structuredOutputSchema: MovieReview })
+
+  const result = await agent.invoke(
+    `Just watched "The Matrix" - what an incredible sci-fi masterpiece!
+     The groundbreaking visual effects and philosophical themes make this
+     a must-watch. Keanu Reeves delivers a solid performance. 9/10!`
+  )
+
+  const review = result.structuredOutput as z.infer<typeof MovieReview>
+  console.log(`Movie: ${review.title}`)
+  console.log(`Rating: ${review.rating}/10`)
+  console.log(`Genre: ${review.genre}`)
+  console.log(`Sentiment: ${review.sentiment}`)
+  // --8<-- [end:structured_output]
+}
+
+void structuredOutputExample

src/content/docs/user-guide/concepts/model-providers/anthropic_imports.ts

@@ -10,3 +10,9 @@ import Anthropic from '@anthropic-ai/sdk'
 import { Agent } from '@strands-agents/sdk'
 import { AnthropicModel } from '@strands-agents/sdk/models/anthropic'
 // --8<-- [end:custom_client_imports]
+
+// --8<-- [start:structured_output_imports]
+import { Agent } from '@strands-agents/sdk'
+import { AnthropicModel } from '@strands-agents/sdk/models/anthropic'
+import { z } from 'zod'
+// --8<-- [end:structured_output_imports]

src/content/docs/user-guide/concepts/model-providers/google.mdx

@@ -256,11 +256,13 @@ except ModelThrottledException as e:
 
 ### Structured Output
 
-Gemini models support structured output through their native JSON schema capabilities. When you use [`Agent.structured_output()`](@api/python/strands.agent.agent#Agent.structured_output), the Strands SDK automatically converts your Pydantic models to Gemini's JSON schema format.
+Gemini models support structured output through their native JSON schema capabilities. Pass a schema to the agent, and Strands converts it to Gemini's JSON schema format and validates the response.
 
 <Tabs>
 <Tab label="Python">
 
+Define a Pydantic model and pass it to [`agent.structured_output()`](@api/python/strands.agent.agent#Agent.structured_output):
+
 ```python
 from pydantic import BaseModel, Field
 from strands import Agent
@@ -303,12 +305,18 @@ print(f"Sentiment: {result.sentiment}")
 </Tab>
 <Tab label="TypeScript">
 
-```ts
-// Structured output is not yet supported for Gemini in the TypeScript SDK
+Define a Zod schema and pass it as `structuredOutputSchema`. Validated output is on `result.structuredOutput`:
+
+```typescript
+--8<-- "user-guide/concepts/model-providers/google_imports.ts:structured_output_imports"
+
+--8<-- "user-guide/concepts/model-providers/google.ts:structured_output"
 ```
 </Tab>
 </Tabs>
 
+For schema patterns, error handling, and per-invocation overrides, see [Structured Output](../agents/structured-output/).
+
 ### Custom client
 
 Users can pass their own custom Gemini client to the GeminiModel for Strands Agents to use directly. Users are responsible for handling the lifecycle (e.g., closing) of the client.