@breadstone/archipel-mcp 0.0.43 → 0.0.45

package/data/packages/platform-intelligence/api/index.md

@@ -9,50 +9,37 @@ editUrl: false
 
 | Class | Description |
 | ------ | ------ |
-| [IntelligenceCapabilityRegistrarBase](Class.IntelligenceCapabilityRegistrarBase) | Provides a reusable registration flow that allows feature modules to contribute capabilities to the global intelligence registry while keeping their implementation details private. |
-| [IntelligenceCapabilityRegistry](Class.IntelligenceCapabilityRegistry) | Central registry responsible for resolving intelligence capabilities based on intent metadata. |
 | [IntelligenceConfigurationError](Class.IntelligenceConfigurationError) | Error thrown when an intelligence provider configuration is invalid or missing. |
-| [IntelligenceHealthIndicator](Class.IntelligenceHealthIndicator) | Health indicator for the intelligence infrastructure. Verifies that at least one intelligence capability is registered. |
-| [IntelligenceModule](Class.IntelligenceModule) | Core module exposing the shared intelligence infrastructure to feature modules. |
+| [IntelligenceHealthIndicator](Class.IntelligenceHealthIndicator) | Health indicator for the intelligence infrastructure. Verifies that the intelligence provider configuration can be resolved. |
+| [IntelligenceModule](Class.IntelligenceModule) | Core module exposing the shared intelligence infrastructure. |
 | [IntelligenceProviderError](Class.IntelligenceProviderError) | Error thrown when an intelligence provider call fails. |
 | [IntelligenceTextGenerator](Class.IntelligenceTextGenerator) | Executes text completions using the configured intelligence provider. |
+| [IntelligenceToolBase](Class.IntelligenceToolBase) | Base class for class-based AI SDK tools. |
+| [IntelligenceToolRegistry](Class.IntelligenceToolRegistry) | Registry for class-based intelligence tools. |
 | [IntelligenceValidationError](Class.IntelligenceValidationError) | Error thrown when an intelligence input validation fails. |
 
 ## Interfaces
 
 | Interface | Description |
 | ------ | ------ |
-| [IIntelligenceArtifact](Interface.IIntelligenceArtifact) | Represents a structured artifact returned by a capability. |
-| [IIntelligenceCapability](Interface.IIntelligenceCapability) | Abstraction implemented by all capability providers. |
-| [IIntelligenceCapabilityMetadata](Interface.IIntelligenceCapabilityMetadata) | Metadata describing a capability for orchestration and analytics purposes. |
-| [IIntelligenceCapabilityPayload](Interface.IIntelligenceCapabilityPayload) | Payload forwarded to capabilities for execution. |
-| [IIntelligenceCapabilityRegistry](Interface.IIntelligenceCapabilityRegistry) | Registry abstraction responsible for resolving capabilities. |
-| [IIntelligenceCapabilityResult](Interface.IIntelligenceCapabilityResult) | Represents the outcome produced by a capability execution. |
 | [IIntelligenceCompletionUsage](Interface.IIntelligenceCompletionUsage) | Captures usage telemetry returned by the intelligence provider. |
-| [IIntelligenceContext](Interface.IIntelligenceContext) | Describes the context aggregated before routing a request to a capability. |
-| [IIntelligenceContextBuilder](Interface.IIntelligenceContextBuilder) | Responsible for composing the context supplied to capabilities. |
-| [IIntelligenceConversationMessageSnapshot](Interface.IIntelligenceConversationMessageSnapshot) | Represents a single message returned within a conversation snapshot. |
-| [IIntelligenceConversationSnapshot](Interface.IIntelligenceConversationSnapshot) | Represents a lightweight snapshot of a conversation used for context building. |
-| [IIntelligenceFollowUpQuestion](Interface.IIntelligenceFollowUpQuestion) | Represents a follow-up question suggested to keep the dialogue active. |
-| [IIntelligenceIntent](Interface.IIntelligenceIntent) | Represents the structured intent resolved from a user message. |
-| [IIntelligenceIntentEntity](Interface.IIntelligenceIntentEntity) | Represents an entity extracted from a resolved intelligence intent. |
-| [IIntelligenceMessageModel](Interface.IIntelligenceMessageModel) | Represents a normalized message stored in persistence. |
-| [IIntelligenceMessagePayload](Interface.IIntelligenceMessagePayload) | Carries the payload submitted when messaging the intelligence entrypoint. |
-| [IIntelligencePrompt](Interface.IIntelligencePrompt) | Represents the input supplied to the intelligence text generator. |
-| [IIntelligencePromptMessage](Interface.IIntelligencePromptMessage) | Describes a normalized message used for text generation prompts. |
+| [IIntelligenceModuleOptions](Interface.IIntelligenceModuleOptions) | Options for configuring the intelligence module. |
 | [IIntelligenceProviderConfiguration](Interface.IIntelligenceProviderConfiguration) | Describes the resolved configuration for the intelligence provider. |
-| [IIntelligenceResponseMessage](Interface.IIntelligenceResponseMessage) | Represents a single assistant message returned by a capability. |
 | [IIntelligenceTextCompletion](Interface.IIntelligenceTextCompletion) | Represents the normalized completion result produced by the intelligence provider. |
 | [IIntelligenceTextGenerationOptions](Interface.IIntelligenceTextGenerationOptions) | Options that can be supplied when generating text with the intelligence provider. |
 | [IIntelligenceTextGenerator](Interface.IIntelligenceTextGenerator) | Abstraction responsible for executing text completions using the configured provider. |
+| [IIntelligenceTextStreamingOptions](Interface.IIntelligenceTextStreamingOptions) | Options that can be supplied when streaming text with the intelligence provider. |
+| [IIntelligenceTool](Interface.IIntelligenceTool) | Minimal shape required by the intelligence tool registry. |
+| [IIntelligenceToolRegistry](Interface.IIntelligenceToolRegistry) | Contract for the intelligence tool registry. |
 
 ## Type Aliases
 
 | Type Alias | Description |
 | ------ | ------ |
-| [IntelligenceConversationMessageRole](TypeAlias.IntelligenceConversationMessageRole) | Represents the union of supported conversation message roles. |
-| [IntelligenceLanguageModelLoader](TypeAlias.IntelligenceLanguageModelLoader) | Represents a factory responsible for resolving a configured language model instance. |
+| [IntelligenceLanguageModelLoader](TypeAlias.IntelligenceLanguageModelLoader) | Represents a factory responsible for creating a configured language model instance. |
+| [IntelligenceLanguageModelLoaders](TypeAlias.IntelligenceLanguageModelLoaders) | Maps configured intelligence providers to their tree-shakable model loader. |
 | [IntelligenceProviderName](TypeAlias.IntelligenceProviderName) | Represents the union of supported intelligence provider identifiers. |
+| [IntelligenceTextStream](TypeAlias.IntelligenceTextStream) | Native AI SDK streaming result returned by the intelligence text generator. |
 
 ## Variables
 
@@ -60,11 +47,17 @@ editUrl: false
 | ------ | ------ |
 | [ANTHROPIC\_API\_KEY](Variable.ANTHROPIC_API_KEY) | Anthropic-specific API key. |
 | [ANTHROPIC\_BASE\_URL](Variable.ANTHROPIC_BASE_URL) | Anthropic-specific base URL. |
-| [GEMINI\_API\_KEY](Variable.GEMINI_API_KEY) | Google-specific Gemini API key. |
+| [ANTHROPIC\_CONFIG\_ENTRIES](Variable.ANTHROPIC_CONFIG_ENTRIES) | Configuration entries used by the Anthropic intelligence provider. |
+| [AnthropicIntelligenceToolNames](Variable.AnthropicIntelligenceToolNames) | Anthropic provider-defined tool names exposed through Archipel. |
+| [GEMINI\_API\_KEY](Variable.GEMINI_API_KEY) | Google-specific Gemini API key alias. |
 | [GOOGLE\_API\_KEY](Variable.GOOGLE_API_KEY) | Google-specific API key. |
 | [GOOGLE\_BASE\_URL](Variable.GOOGLE_BASE_URL) | Google-specific base URL. |
+| [GOOGLE\_CONFIG\_ENTRIES](Variable.GOOGLE_CONFIG_ENTRIES) | Configuration entries used by the Google intelligence provider. |
+| [GoogleIntelligenceToolNames](Variable.GoogleIntelligenceToolNames) | Google provider-defined tool names exposed through Archipel. |
 | [GROK\_API\_KEY](Variable.GROK_API_KEY) | Grok-specific API key. |
 | [GROK\_BASE\_URL](Variable.GROK_BASE_URL) | Grok-specific base URL. |
+| [GROK\_CONFIG\_ENTRIES](Variable.GROK_CONFIG_ENTRIES) | Configuration entries used by the Grok intelligence provider. |
+| [GrokIntelligenceToolNames](Variable.GrokIntelligenceToolNames) | Grok provider-defined tool names exposed through Archipel. |
 | [INTELLIGENCE\_API\_KEY](Variable.INTELLIGENCE_API_KEY) | Global API key override for the intelligence provider. |
 | [INTELLIGENCE\_BASE\_URL](Variable.INTELLIGENCE_BASE_URL) | Global base URL override for the intelligence provider. |
 | [INTELLIGENCE\_MAX\_OUTPUT\_TOKENS](Variable.INTELLIGENCE_MAX_OUTPUT_TOKENS) | Maximum number of output tokens for the AI model. |
@@ -72,21 +65,67 @@ editUrl: false
 | [INTELLIGENCE\_PROVIDER](Variable.INTELLIGENCE_PROVIDER) | Intelligence provider name (e.g. openai, anthropic, google, grok). |
 | [INTELLIGENCE\_TEMPERATURE](Variable.INTELLIGENCE_TEMPERATURE) | Sampling temperature for the AI model. |
 | [INTELLIGENCE\_TOP\_P](Variable.INTELLIGENCE_TOP_P) | Top-p (nucleus sampling) for the AI model. |
-| [IntelligenceConversationMessageRoles](Variable.IntelligenceConversationMessageRoles) | Enumerates the conversation roles used for contextual snapshots and messages. |
 | [IntelligenceProviderNames](Variable.IntelligenceProviderNames) | Enumerates the supported model providers powering the intelligence pipeline. |
 | [OPENAI\_API\_KEY](Variable.OPENAI_API_KEY) | OpenAI-specific API key. |
 | [OPENAI\_BASE\_URL](Variable.OPENAI_BASE_URL) | OpenAI-specific base URL. |
+| [OPENAI\_CONFIG\_ENTRIES](Variable.OPENAI_CONFIG_ENTRIES) | Configuration entries used by the OpenAI intelligence provider. |
+| [OpenAIIntelligenceToolNames](Variable.OpenAIIntelligenceToolNames) | OpenAI provider-defined tool names exposed through Archipel. |
 | [PLATFORM\_INTELLIGENCE\_CONFIG\_ENTRIES](Variable.PLATFORM_INTELLIGENCE_CONFIG_ENTRIES) | All configuration entries required by `platform-intelligence`. |
-| [XAI\_API\_KEY](Variable.XAI_API_KEY) | X.AI-specific API key (alias for Grok). |
-| [XAI\_BASE\_URL](Variable.XAI_BASE_URL) | X.AI-specific base URL (alias for Grok). |
+| [XAI\_API\_KEY](Variable.XAI_API_KEY) | xAI-specific API key alias for Grok. |
+| [XAI\_BASE\_URL](Variable.XAI_BASE_URL) | xAI-specific base URL alias for Grok. |
 
 ## Functions
 
 | Function | Description |
 | ------ | ------ |
+| [createAnthropicAdvisor20260301Tool](Function.createAnthropicAdvisor20260301Tool) | Creates an Anthropic advisor tool registration. |
+| [createAnthropicBash20241022Tool](Function.createAnthropicBash20241022Tool) | Creates an Anthropic bash tool registration for the 2024-10-22 version. |
+| [createAnthropicBash20250124Tool](Function.createAnthropicBash20250124Tool) | Creates an Anthropic bash tool registration for the 2025-01-24 version. |
+| [createAnthropicCodeExecution20250522Tool](Function.createAnthropicCodeExecution20250522Tool) | Creates an Anthropic code-execution tool registration for the 2025-05-22 version. |
+| [createAnthropicCodeExecution20250825Tool](Function.createAnthropicCodeExecution20250825Tool) | Creates an Anthropic code-execution tool registration for the 2025-08-25 version. |
+| [createAnthropicCodeExecution20260120Tool](Function.createAnthropicCodeExecution20260120Tool) | Creates an Anthropic code-execution tool registration for the 2026-01-20 version. |
+| [createAnthropicComputer20241022Tool](Function.createAnthropicComputer20241022Tool) | Creates an Anthropic computer-use tool registration for the 2024-10-22 version. |
+| [createAnthropicComputer20250124Tool](Function.createAnthropicComputer20250124Tool) | Creates an Anthropic computer-use tool registration for the 2025-01-24 version. |
+| [createAnthropicComputer20251124Tool](Function.createAnthropicComputer20251124Tool) | Creates an Anthropic computer-use tool registration for the 2025-11-24 version. |
+| [createAnthropicMemory20250818Tool](Function.createAnthropicMemory20250818Tool) | Creates an Anthropic memory tool registration. |
+| [createAnthropicTextEditor20241022Tool](Function.createAnthropicTextEditor20241022Tool) | Creates an Anthropic text-editor tool registration for the 2024-10-22 version. |
+| [createAnthropicTextEditor20250124Tool](Function.createAnthropicTextEditor20250124Tool) | Creates an Anthropic text-editor tool registration for the 2025-01-24 version. |
+| [createAnthropicTextEditor20250429Tool](Function.createAnthropicTextEditor20250429Tool) | Creates an Anthropic text-editor tool registration for the 2025-04-29 version. |
+| [createAnthropicTextEditor20250728Tool](Function.createAnthropicTextEditor20250728Tool) | Creates an Anthropic text-editor tool registration for the 2025-07-28 version. |
+| [createAnthropicToolSearchBM2520251119Tool](Function.createAnthropicToolSearchBM2520251119Tool) | Creates an Anthropic BM25 tool-search tool registration. |
+| [createAnthropicToolSearchRegex20251119Tool](Function.createAnthropicToolSearchRegex20251119Tool) | Creates an Anthropic regex tool-search tool registration. |
+| [createAnthropicWebFetch20250910Tool](Function.createAnthropicWebFetch20250910Tool) | Creates an Anthropic web-fetch tool registration for the 2025-09-10 version. |
+| [createAnthropicWebFetch20260209Tool](Function.createAnthropicWebFetch20260209Tool) | Creates an Anthropic web-fetch tool registration for the 2026-02-09 version. |
+| [createAnthropicWebSearch20250305Tool](Function.createAnthropicWebSearch20250305Tool) | Creates an Anthropic web-search tool registration for the 2025-03-05 version. |
+| [createAnthropicWebSearch20260209Tool](Function.createAnthropicWebSearch20260209Tool) | Creates an Anthropic web-search tool registration for the 2026-02-09 version. |
+| [createGoogleCodeExecutionTool](Function.createGoogleCodeExecutionTool) | Creates a Google code-execution tool registration. |
+| [createGoogleEnterpriseWebSearchTool](Function.createGoogleEnterpriseWebSearchTool) | Creates a Google enterprise-web-search tool registration. |
+| [createGoogleFileSearchTool](Function.createGoogleFileSearchTool) | Creates a Google file-search tool registration. |
+| [createGoogleGoogleMapsTool](Function.createGoogleGoogleMapsTool) | Creates a Google Maps grounding tool registration. |
+| [createGoogleGoogleSearchTool](Function.createGoogleGoogleSearchTool) | Creates a Google Search grounding tool registration. |
+| [createGoogleUrlContextTool](Function.createGoogleUrlContextTool) | Creates a Google URL context tool registration. |
+| [createGoogleVertexRagStoreTool](Function.createGoogleVertexRagStoreTool) | Creates a Google Vertex RAG Store tool registration. |
+| [createGrokCodeExecutionTool](Function.createGrokCodeExecutionTool) | Creates a Grok code-execution tool registration. |
+| [createGrokFileSearchTool](Function.createGrokFileSearchTool) | Creates a Grok file-search tool registration. |
+| [createGrokMcpServerTool](Function.createGrokMcpServerTool) | Creates a Grok MCP server tool registration. |
+| [createGrokViewImageTool](Function.createGrokViewImageTool) | Creates a Grok image-understanding tool registration. |
+| [createGrokViewXVideoTool](Function.createGrokViewXVideoTool) | Creates a Grok X-video understanding tool registration. |
+| [createGrokWebSearchTool](Function.createGrokWebSearchTool) | Creates a Grok web-search tool registration. |
+| [createGrokXSearchTool](Function.createGrokXSearchTool) | Creates a Grok X-search tool registration. |
+| [createIntelligenceTool](Function.createIntelligenceTool) | Adapts a native AI SDK tool to the Archipel intelligence tool schema. |
+| [createOpenAIApplyPatchTool](Function.createOpenAIApplyPatchTool) | Creates an OpenAI apply-patch tool registration. |
+| [createOpenAICodeInterpreterTool](Function.createOpenAICodeInterpreterTool) | Creates an OpenAI code-interpreter tool registration. |
+| [createOpenAICustomTool](Function.createOpenAICustomTool) | Creates an OpenAI custom provider-defined tool registration. |
+| [createOpenAIFileSearchTool](Function.createOpenAIFileSearchTool) | Creates an OpenAI file-search tool registration. |
+| [createOpenAIImageGenerationTool](Function.createOpenAIImageGenerationTool) | Creates an OpenAI image-generation tool registration. |
+| [createOpenAILocalShellTool](Function.createOpenAILocalShellTool) | Creates an OpenAI local-shell tool registration. |
+| [createOpenAIMcpTool](Function.createOpenAIMcpTool) | Creates an OpenAI MCP connector tool registration. |
+| [createOpenAIShellTool](Function.createOpenAIShellTool) | Creates an OpenAI shell tool registration. |
+| [createOpenAIToolSearchTool](Function.createOpenAIToolSearchTool) | Creates an OpenAI tool-search tool registration. |
+| [createOpenAIWebSearchPreviewTool](Function.createOpenAIWebSearchPreviewTool) | Creates an OpenAI web-search-preview tool registration. |
+| [createOpenAIWebSearchTool](Function.createOpenAIWebSearchTool) | Creates an OpenAI web-search tool registration. |
 | [createProviderOptions](Function.createProviderOptions) | Creates the provider options object consumed by the AI SDK model factories. |
-| [loadAnthropicLanguageModel](Function.loadAnthropicLanguageModel) | Loads the Anthropic language model based on the resolved provider configuration. |
-| [loadGoogleLanguageModel](Function.loadGoogleLanguageModel) | Loads the Google (Gemini) language model based on the resolved provider configuration. |
-| [loadGrokLanguageModel](Function.loadGrokLanguageModel) | Loads the Grok (xAI) language model based on the resolved provider configuration. |
-| [loadOpenAILanguageModel](Function.loadOpenAILanguageModel) | Loads the OpenAI compatible language model based on the resolved provider configuration. |
-| [loadProviderFactory](Function.loadProviderFactory) | Dynamically loads an AI SDK provider factory and returns the exported function reference. |
+| [loadAnthropicLanguageModel](Function.loadAnthropicLanguageModel) | Creates the Anthropic language model from the resolved provider configuration. |
+| [loadGoogleLanguageModel](Function.loadGoogleLanguageModel) | Creates the Google Gemini language model from the resolved provider configuration. |
+| [loadGrokLanguageModel](Function.loadGrokLanguageModel) | Creates the Grok language model through the native xAI provider. |
+| [loadOpenAILanguageModel](Function.loadOpenAILanguageModel) | Creates the OpenAI language model from the resolved provider configuration. |

package/data/packages/platform-intelligence/index.md

@@ -1,14 +1,14 @@
 ---
 title: platform-intelligence
-description: Multi-provider AI text generation with capability registry and intent-based orchestration.
+description: Multi-provider AI text generation, streaming, and tool calling.
 order: 16
-tags: [intelligence, ai, openai, anthropic, google, grok, text-generation, capability-registry, health]
+tags: [intelligence, ai, openai, anthropic, google, grok, text-generation, streaming, tool-calling, health]
 package: '@breadstone/archipel-platform-intelligence'
 ---
 
 # platform-intelligence
 
-Multi-provider AI text generation library supporting OpenAI, Anthropic, Google Generative AI, and Grok. Features a capability registry that maps business intents to provider-specific configurations, enabling intent-based orchestration without coupling consumers to a specific LLM.
+Multi-provider AI text generation library supporting OpenAI, Anthropic, Google Generative AI, and Grok. Tool orchestration is delegated to the AI SDK through native and provider-defined tool definitions, `toolChoice`, `activeTools`, and `stopWhen`. Advanced use cases can pass native AI SDK prompts, request-level models, provider options, headers, telemetry, output settings, and step hooks through the platform generator.
 
 **Package:** `@breadstone/archipel-platform-intelligence`
 
@@ -18,101 +18,308 @@ Multi-provider AI text generation library supporting OpenAI, Anthropic, Google G
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { IntelligenceModule } from '@breadstone/archipel-platform-intelligence';
+import { IntelligenceModule, IntelligenceProviderNames } from '@breadstone/archipel-platform-intelligence';
+import { loadOpenAILanguageModel } from '@breadstone/archipel-platform-intelligence/providers/openai';
 
 @Module({
-  imports: [IntelligenceModule],
+  imports: [
+    IntelligenceModule.register({
+      providerLoaders: {
+        [IntelligenceProviderNames.OpenAI]: loadOpenAILanguageModel,
+      },
+    }),
+  ],
 })
 export class AppModule {}
 ```
 
 ---
 
-## Provider Packages
+## Provider Subpaths
 
-Install only the providers you need:
+Import only the providers you need:
 
-| Provider  | Package                                                |
-| --------- | ------------------------------------------------------ |
-| OpenAI    | `@breadstone/archipel-platform-intelligence/openai`    |
-| Anthropic | `@breadstone/archipel-platform-intelligence/anthropic` |
-| Google    | `@breadstone/archipel-platform-intelligence/google`    |
-| Grok      | `@breadstone/archipel-platform-intelligence/grok`      |
+| Provider  | Subpath                                                          |
+| --------- | ---------------------------------------------------------------- |
+| OpenAI    | `@breadstone/archipel-platform-intelligence/providers/openai`    |
+| Anthropic | `@breadstone/archipel-platform-intelligence/providers/anthropic` |
+| Google    | `@breadstone/archipel-platform-intelligence/providers/google`    |
+| Grok      | `@breadstone/archipel-platform-intelligence/providers/grok`      |
+
+Provider-native tool wrappers are exported through matching `/tools` subpaths, for example `@breadstone/archipel-platform-intelligence/providers/grok/tools`.
 
 ---
 
-## Text Generation
+## Tool Registration
 
-Inject `IntelligenceTextGenerator` and call `generateText()`:
+Tools can be normal Nest providers or direct `IIntelligenceTool` instances. Register classes for custom application tools, or register provider-native wrappers from provider subpaths.
 
 ```typescript
-import { Injectable } from '@nestjs/common';
-import { IntelligenceTextGenerator, IIntelligencePrompt } from '@breadstone/archipel-platform-intelligence';
+import { Injectable, Module } from '@nestjs/common';
+import { tool, type Tool } from 'ai';
+import { z } from 'zod';
+import { IntelligenceModule, IntelligenceProviderNames, IntelligenceToolBase } from '@breadstone/archipel-platform-intelligence';
+import { loadOpenAILanguageModel } from '@breadstone/archipel-platform-intelligence/providers/openai';
+
+interface ICustomerSearchInput {
+  readonly query: string;
+}
 
-@Injectable()
-export class SummaryService {
-  constructor(private readonly _textGenerator: IntelligenceTextGenerator) {}
+interface ICustomerSearchOutput {
+  readonly customers: ReadonlyArray<string>;
+}
 
-  async summarize(content: string): Promise<string> {
-    const prompt: IIntelligencePrompt = {
-      system: 'You are a concise summarizer.',
-      messages: [{ role: 'user', content }],
-    };
+@Injectable()
+export class CustomerSearchTool extends IntelligenceToolBase<ICustomerSearchInput, ICustomerSearchOutput> {
+  public override get name(): string {
+    return 'searchCustomers';
+  }
 
-    const result = await this._textGenerator.generateText(prompt, {
-      provider: 'openai',
-      model: 'gpt-4o',
-      temperature: 0.3,
+  public override get tool(): Tool<ICustomerSearchInput, ICustomerSearchOutput> {
+    return tool({
+      description: 'Searches customers by name, email, or company.',
+      inputSchema: z.object({
+        query: z.string().describe('Customer search query'),
+      }),
+      execute: async (input) => ({ customers: [input.query] }),
     });
-
-    return result.text;
   }
 }
+
+@Module({
+  imports: [
+    IntelligenceModule.register({
+      providerLoaders: {
+        [IntelligenceProviderNames.OpenAI]: loadOpenAILanguageModel,
+      },
+      tools: [CustomerSearchTool],
+    }),
+  ],
+})
+export class AppModule {}
 ```
 
----
+### Provider-Native Tools
+
+Provider SDKs expose built-in tools such as web search, file search, code execution, and URL context. Archipel exports wrappers from provider subpaths so each tool is compatible with `IIntelligenceTool` without importing unused provider SDKs from the root entry.
+
+```typescript
+import { Module } from '@nestjs/common';
+import { IntelligenceModule, IntelligenceProviderNames } from '@breadstone/archipel-platform-intelligence';
+import { loadOpenAILanguageModel } from '@breadstone/archipel-platform-intelligence/providers/openai';
+import { createOpenAIWebSearchTool } from '@breadstone/archipel-platform-intelligence/providers/openai/tools';
 
-## Capability Registry
+@Module({
+  imports: [
+    IntelligenceModule.register({
+      providerLoaders: {
+        [IntelligenceProviderNames.OpenAI]: loadOpenAILanguageModel,
+      },
+      tools: [createOpenAIWebSearchTool({ searchContextSize: 'medium' })],
+    }),
+  ],
+})
+export class AppModule {}
+```
 
-The capability registry decouples consumers from specific providers and models by mapping business intents to configurations.
+Provider-native wrappers cover OpenAI web search, file search, code interpreter, image generation, shell, MCP, and tool search; Google Search, Enterprise Web Search, URL Context, Code Execution, File Search, Maps, and Vertex RAG Store; versioned Anthropic web search, web fetch, code execution, bash, text editor, computer, memory, tool search, and advisor tools; and Grok web search, X search, file search, code execution, MCP, image understanding, and X-video understanding.
 
-### Defining Capabilities
+The detailed AI text generation guide includes OpenAI recipes for spreadsheet analysis with Code Interpreter, image generation with generated files, deferred tool loading via Tool Search, and grammar-constrained custom tools. In the currently installed OpenAI SDK, `customTool()` constrains provider output but does not run a local `execute` callback; use a normal `tool()` when local execution is required.
+
+### Native AI SDK Passthrough
+
+`generateText()` and `streamText()` accept native AI SDK `Prompt` objects directly. The options intentionally extend the native AI SDK call options, so provider-specific features can flow through even when Archipel has no dedicated wrapper for them.
+
+The configured platform model is used by default. For exact AI SDK model factories, pass `model` per request. When every call provides a native model, set `validateOnModuleInit: false` to skip startup validation of platform provider configuration.
 
 ```typescript
-import { IIntelligenceCapability } from '@breadstone/archipel-platform-intelligence';
-
-const SUMMARIZE_CAPABILITY: IIntelligenceCapability = {
-  intent: 'summarize',
-  provider: 'openai',
-  model: 'gpt-4o',
-  temperature: 0.3,
-  maxTokens: 1024,
-};
+import { openai } from '@ai-sdk/openai';
+import { Injectable, Module } from '@nestjs/common';
+import { IntelligenceModule, IntelligenceTextGenerator } from '@breadstone/archipel-platform-intelligence';
+
+@Module({
+  imports: [
+    IntelligenceModule.register({
+      validateOnModuleInit: false,
+    }),
+  ],
+})
+export class RawAiSdkModule {}
+
+@Injectable()
+export class RawAiSdkRecipeService {
+  public constructor(private readonly _textGenerator: IntelligenceTextGenerator) {}
+
+  public async answerWithNativeOptions(): Promise<string> {
+    const completion = await this._textGenerator.generateText(
+      {
+        system: 'Answer concisely and include assumptions.',
+        prompt: 'Compare the operational risks of outdoor work tomorrow.',
+      },
+      {
+        model: openai.responses('gpt-5'),
+        headers: { 'x-use-case': 'outdoor-risk' },
+        providerOptions: {
+          openai: {
+            reasoningEffort: 'medium',
+          },
+        },
+        seed: 42,
+      },
+    );
+
+    return completion.text;
+  }
+}
 ```
 
-### Registering via IntelligenceCapabilityRegistrarBase
+### Outdoor Order Weather Risk Example
+
+Use a class-based application tool for tenant data and a provider-native web search tool for current weather context. Set `INTELLIGENCE_PROVIDER=openai` and `INTELLIGENCE_MODEL=gpt-5` in configuration when this flow should use GPT-5.
 
 ```typescript
-import { Injectable } from '@nestjs/common';
+import { Injectable, Module } from '@nestjs/common';
+import { stepCountIs, tool, type Tool } from 'ai';
+import { z } from 'zod';
 import {
-  IntelligenceCapabilityRegistrarBase,
-  IIntelligenceCapabilityRegistry,
+  IntelligenceModule,
+  IntelligenceProviderNames,
+  IntelligenceTextGenerator,
+  IntelligenceToolBase,
+  type IIntelligenceTextCompletion,
 } from '@breadstone/archipel-platform-intelligence';
+import { OpenAIIntelligenceToolNames, loadOpenAILanguageModel } from '@breadstone/archipel-platform-intelligence/providers/openai';
+import { createOpenAIWebSearchTool } from '@breadstone/archipel-platform-intelligence/providers/openai/tools';
+
+interface IOutdoorOrderLookupInput {
+  readonly date: string;
+}
+
+interface IOutdoorOrderLookupOutput {
+  readonly date: string;
+  readonly orders: ReadonlyArray<{
+    readonly id: string;
+    readonly location: string;
+    readonly scheduledAt: string;
+    readonly outdoorWork: boolean;
+  }>;
+}
+
+@Injectable()
+export class OutdoorOrdersTool extends IntelligenceToolBase<IOutdoorOrderLookupInput, IOutdoorOrderLookupOutput> {
+  public override get name(): string {
+    return 'get_outdoor_orders';
+  }
+
+  public override get tool(): Tool<IOutdoorOrderLookupInput, IOutdoorOrderLookupOutput> {
+    return tool({
+      description: 'Returns outdoor field orders for the current tenant and date.',
+      inputSchema: z.object({
+        date: z.string().describe('Date in YYYY-MM-DD format'),
+      }),
+      execute: async (input: IOutdoorOrderLookupInput) => ({
+        date: input.date,
+        orders: [
+          {
+            id: 'ord_4711',
+            location: 'Berlin',
+            scheduledAt: `${input.date}T08:00:00+02:00`,
+            outdoorWork: true,
+          },
+        ],
+      }),
+    });
+  }
+}
+
+@Injectable()
+export class OutdoorOrderRiskAnalysisService {
+  public constructor(private readonly _textGenerator: IntelligenceTextGenerator) {}
+
+  public async analyseOutdoorOrders(date: string): Promise<{ readonly text: string; readonly sources: IIntelligenceTextCompletion['sources'] }> {
+    const result = await this._textGenerator.generateText(
+      {
+        system: 'You assess weather-related risks for tenant outdoor field orders.',
+        messages: [{ role: 'user', content: `Review outdoor field orders for ${date} and flag weather-related risks.` }],
+      },
+      {
+        toolChoice: 'auto',
+        activeTools: ['get_outdoor_orders', OpenAIIntelligenceToolNames.WebSearch],
+        stopWhen: stepCountIs(3),
+      },
+    );
+
+    return {
+      text: result.text,
+      sources: result.sources,
+    };
+  }
+}
+
+@Module({
+  imports: [
+    IntelligenceModule.register({
+      providerLoaders: {
+        [IntelligenceProviderNames.OpenAI]: loadOpenAILanguageModel,
+      },
+      tools: [
+        OutdoorOrdersTool,
+        createOpenAIWebSearchTool({
+          externalWebAccess: true,
+          searchContextSize: 'medium',
+          filters: { allowedDomains: ['dwd.de'] },
+        }),
+      ],
+    }),
+  ],
+  providers: [OutdoorOrderRiskAnalysisService],
+})
+export class OutdoorOrderRiskAnalysisModule {}
+```
+
+---
+
+## Text Generation
+
+Inject `IntelligenceTextGenerator` and call `generateText()`:
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import type { Prompt } from 'ai';
+import { IntelligenceTextGenerator } from '@breadstone/archipel-platform-intelligence';
 
 @Injectable()
-export class AppCapabilityRegistrar extends IntelligenceCapabilityRegistrarBase {
-  protected registerCapabilities(registry: IIntelligenceCapabilityRegistry): void {
-    registry.register(SUMMARIZE_CAPABILITY);
-    registry.register(TRANSLATE_CAPABILITY);
+export class SummaryService {
+  constructor(private readonly _textGenerator: IntelligenceTextGenerator) {}
+
+  async summarize(content: string): Promise<string> {
+    const prompt: Prompt = {
+      system: 'You are a concise summarizer.',
+      messages: [{ role: 'user', content }],
+    };
+
+    const result = await this._textGenerator.generateText(prompt, {
+      temperature: 0.3,
+      toolChoice: 'auto',
+    });
+
+    return result.text;
   }
 }
 ```
 
-### Resolving at Runtime
+---
+
+## Streaming
+`streamText()` uses the same registered tools and returns the native AI SDK stream result.
 
 ```typescript
-const capability = this._registry.resolve('summarize');
-const result = await this._textGenerator.generateText(prompt, capability);
+const stream = await this._textGenerator.streamText(prompt, {
+  activeTools: ['searchCustomers'],
+  stopWhen: stepCountIs(3),
+});
+
+return stream.toUIMessageStreamResponse();
 ```
 
 ---
@@ -121,10 +328,10 @@ const result = await this._textGenerator.generateText(prompt, capability);
 
 | Variable                         | Description                  | Required           |
 | -------------------------------- | ---------------------------- | ------------------ |
-| `INTELLIGENCE_OPENAI_API_KEY`    | OpenAI API key               | If using OpenAI    |
-| `INTELLIGENCE_ANTHROPIC_API_KEY` | Anthropic API key            | If using Anthropic |
-| `INTELLIGENCE_GOOGLE_API_KEY`    | Google Generative AI API key | If using Google    |
-| `INTELLIGENCE_GROK_API_KEY`      | Grok / xAI API key           | If using Grok      |
+| `OPENAI_API_KEY`                 | OpenAI API key               | If using OpenAI    |
+| `ANTHROPIC_API_KEY`              | Anthropic API key            | If using Anthropic |
+| `GOOGLE_API_KEY`                 | Google Generative AI API key | If using Google    |
+| `GROK_API_KEY`                   | Grok / xAI API key           | If using Grok      |
 
 ---
 
@@ -142,9 +349,7 @@ Override the timeout per call via the options parameter:
 
 ```typescript
 const result = await this._textGenerator.generateText(prompt, {
-  provider: 'openai',
-  model: 'gpt-4o',
-  timeoutMs: 15_000, // 15-second timeout
+  timeoutMs: 15_000,
 });
 ```
 
@@ -160,7 +365,7 @@ The library provides three domain error classes for different failure scenarios:
 | ---------------------------------- | ----------------------------- | --------------------------------------------------------------------- |
 | `IntelligenceProviderError`        | `INTELLIGENCE_PROVIDER`       | Provider SDK failures during text generation                          |
 | `IntelligenceValidationError`      | `INTELLIGENCE_VALIDATION`     | Invalid generation parameters (temperature, topP, maxOutputTokens)    |
-| `IntelligenceConfigurationError`   | `INTELLIGENCE_CONFIGURATION`  | Unsupported provider, missing API key, or missing SDK package         |
+| `IntelligenceConfigurationError`   | `INTELLIGENCE_CONFIGURATION`  | Unsupported provider, missing API key, or missing provider loader     |
 
 ```typescript
 import {
@@ -174,27 +379,33 @@ import {
 
 ## Lifecycle
 
-`IntelligenceTextGenerator` implements `OnModuleInit` and validates the provider configuration eagerly at startup. Missing API keys or unsupported providers throw `IntelligenceConfigurationError` before the first request is processed.
+`IntelligenceTextGenerator` implements `OnModuleInit` and validates the provider configuration plus registered provider loader eagerly at startup. Missing API keys, unsupported providers, or missing loaders throw `IntelligenceConfigurationError` before the first request is processed.
 
 ---
 
-## Capability Registry Limits
+## Tool Registry Limits
 
-`IntelligenceCapabilityRegistry` enforces a maximum of **500** registered capabilities. Attempts to register beyond this limit are logged as warnings and silently ignored. This prevents unbounded memory growth in applications with dynamic capability registration.
+`IntelligenceToolRegistry` enforces a maximum of **128** registered tools. Attempts to register beyond this limit throw `IntelligenceValidationError` to prevent unbounded memory growth.
 
 ---
 
 ## Health Check
 
-The `IntelligenceHealthIndicator` verifies that an `IntelligenceCapabilityRegistry` is injected. If no registry is available, it reports `disabled: true`. Import it from the `/health` subpath:
+The `IntelligenceHealthIndicator` verifies that provider configuration can be resolved. If no text generator is available, it reports `disabled: true`. Import it from the `/health` subpath:
 
 ```typescript
+import { IntelligenceModule, IntelligenceProviderNames } from '@breadstone/archipel-platform-intelligence';
 import { IntelligenceHealthIndicator } from '@breadstone/archipel-platform-intelligence/health';
+import { loadOpenAILanguageModel } from '@breadstone/archipel-platform-intelligence/providers/openai';
 import { HealthModule } from '@breadstone/archipel-platform-health';
 
 @Module({
   imports: [
-    IntelligenceModule.register({ /* ... */ }),
+    IntelligenceModule.register({
+      providerLoaders: {
+        [IntelligenceProviderNames.OpenAI]: loadOpenAILanguageModel,
+      },
+    }),
     HealthModule.withIndicators([IntelligenceHealthIndicator]),
   ],
 })
@@ -203,7 +414,7 @@ export class AppModule {}
 
 | Key | Check | Dependencies |
 | --- | ----- | ------------ |
-| `intelligence` | `up` if `IntelligenceCapabilityRegistry` injected, else `disabled` | `@Optional() IntelligenceCapabilityRegistry` |
+| `intelligence` | `up` when provider configuration resolves, else `down` | `@Optional() IntelligenceTextGenerator` |
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@breadstone/archipel-mcp",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "description": "MCP server providing Archipel platform knowledge - documentation, query patterns, and coding conventions - to AI development tools.",
   "type": "commonjs",
   "main": "./src/main.js",