@framers/agentos 0.1.1 → 0.1.3

package/README.md

@@ -276,241 +276,291 @@ for await (const chunk of agent.processRequest({
 
 ## Documentation
 
+### Core Concepts
+
 | Guide | Description |
 |-------|-------------|
 | [Architecture](./docs/ARCHITECTURE.md) | System design and component overview |
+| [Guardrails](./docs/GUARDRAILS_USAGE.md) | Safety controls and mid-stream intervention |
+| [Extensions](./docs/RFC_EXTENSION_STANDARDS.md) | Extension system and standards |
+| [Ecosystem](./docs/ECOSYSTEM.md) | Related repos and packages |
+
+### Agent Features
+
+| Guide | Description |
+|-------|-------------|
 | [Planning Engine](./docs/PLANNING_ENGINE.md) | Multi-step task planning and execution |
 | [Human-in-the-Loop](./docs/HUMAN_IN_THE_LOOP.md) | Approval workflows and oversight |
 | [Agent Communication](./docs/AGENT_COMMUNICATION.md) | Inter-agent messaging patterns |
-| [RAG Configuration](./docs/RAG_MEMORY_CONFIGURATION.md) | Memory and retrieval setup |
+| [Self-Building Agents](./docs/RECURSIVE_SELF_BUILDING_AGENTS.md) | Recursive agent construction |
 | [Structured Output](./docs/STRUCTURED_OUTPUT.md) | JSON schema validation |
 | [Evaluation Framework](./docs/EVALUATION_FRAMEWORK.md) | Testing and quality assurance |
+
+### Storage & Memory
+
+| Guide | Description |
+|-------|-------------|
+| [RAG Configuration](./docs/RAG_MEMORY_CONFIGURATION.md) | Memory and retrieval setup |
+| [SQL Storage](./docs/SQL_STORAGE_QUICKSTART.md) | SQLite/PostgreSQL setup |
+| [Client-Side Storage](./docs/CLIENT_SIDE_STORAGE.md) | Browser storage options |
+
+### Operations
+
+| Guide | Description |
+|-------|-------------|
+| [Cost Optimization](./docs/COST_OPTIMIZATION.md) | Token usage and cost management |
+| [Platform Support](./docs/PLATFORM_SUPPORT.md) | Supported platforms and environments |
+| [Releasing](./docs/RELEASING.md) | How to publish new versions |
 | [API Reference](./docs/api/index.html) | TypeDoc-generated API docs |
+---
+
+## Examples
+
+### Structured Data Extraction
+
+```typescript
+import { AgentOS, StructuredOutputManager } from '@framers/agentos';
+
+const agent = new AgentOS();
+await agent.initialize({
+  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' }
+});
+
+// Extract typed data from unstructured text
+const structured = new StructuredOutputManager({ llmProviderManager: agent.llmProviderManager });
+const contact = await structured.generate({
+  prompt: 'Extract: "Meeting with Sarah Chen (sarah@startup.io) on Jan 15 re: Series A"',
+  schema: {
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      email: { type: 'string', format: 'email' },
+      date: { type: 'string' },
+      topic: { type: 'string' }
+    },
+    required: ['name', 'email']
+  },
+  schemaName: 'ContactInfo'
+});
+// → { name: 'Sarah Chen', email: 'sarah@startup.io', date: 'Jan 15', topic: 'Series A' }
+```
+
+### Human-in-the-Loop Approvals
+
+```typescript
+import { HumanInteractionManager } from '@framers/agentos';
+
+const hitl = new HumanInteractionManager({ defaultTimeoutMs: 300000 });
+
+// Gate high-risk operations with human approval
+const decision = await hitl.requestApproval({
+  action: {
+    type: 'database_mutation',
+    description: 'Archive 50K inactive accounts older than 2 years',
+    severity: 'high',
+    metadata: { affectedRows: 50000, table: 'users' }
+  },
+  alternatives: [
+    { action: 'soft_delete', description: 'Mark as inactive instead of archiving' },
+    { action: 'export_first', description: 'Export to CSV before archiving' }
+  ]
+});
+
+if (decision.approved) {
+  await executeArchive();
+} else if (decision.selectedAlternative) {
+  await executeAlternative(decision.selectedAlternative);
+}
+```
+
+### Autonomous Task Planning
+
+```typescript
+import { AgentOS, PlanningEngine } from '@framers/agentos';
+
+const agent = new AgentOS();
+await agent.initialize({
+  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' }
+});
+
+const planner = new PlanningEngine({ llmProvider: agent.llmProviderManager, strategy: 'react' });
+
+// Decompose complex goals into executable steps with ReAct reasoning
+const plan = await planner.generatePlan({
+  goal: 'Migrate authentication from sessions to JWT',
+  constraints: ['Zero downtime', 'Backwards compatible for 30 days', 'Audit logging required'],
+  context: { currentStack: 'Express + Redis sessions', userCount: '50K' }
+});
+
+for await (const step of planner.executePlan(plan.id)) {
+  console.log(`[${step.status}] ${step.action}`);
+  if (step.requiresHumanApproval) {
+    const approved = await promptUser(step.description);
+    if (!approved) break;
+  }
+}
+```
+
+### Multi-Agent Collaboration
+
+```typescript
+import { AgentOS, AgencyRegistry, AgentCommunicationBus } from '@framers/agentos';
+
+// Create specialized agents
+const researcher = new AgentOS();
+await researcher.initialize({ llmProvider: llmConfig, persona: 'Research analyst' });
+
+const writer = new AgentOS();
+await writer.initialize({ llmProvider: llmConfig, persona: 'Technical writer' });
+
+// Register in agency with shared communication
+const agency = new AgencyRegistry();
+const bus = new AgentCommunicationBus();
+agency.register('researcher', researcher, { bus });
+agency.register('writer', writer, { bus });
+
+// Agents coordinate via message passing
+bus.on('research:complete', async ({ findings }) => {
+  await writer.processRequest({
+    message: `Write documentation based on: ${JSON.stringify(findings)}`
+  });
+});
+
+await researcher.processRequest({ message: 'Analyze the authentication module' });
+```
+
+### Guardrails: Mid-Stream Decision Override
+
+```typescript
+import { AgentOS } from '@framers/agentos';
+import { CostCeilingGuardrail } from './guardrails/CostCeilingGuardrail';
+
+const costGuard = new CostCeilingGuardrail({
+  maxCostUsd: 0.05,  // 5 cents per request
+  inputTokenPricePer1k: 0.0001,
+  outputTokenPricePer1k: 0.0002,
+  budgetExceededText: 'Response exceeded cost ceiling. Please refine your request.'
+});
+
+const agent = new AgentOS();
+await agent.initialize({
+  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY },
+  guardrailService: costGuard
+});
+
+// Agent generates expensive response → guardrail intercepts → substitutes budget message
+// Agents can "change their mind" before delivery based on cost, content policy, or quality checks
+```
+
+See [Guardrails Usage Guide](./docs/GUARDRAILS_USAGE.md) for complete documentation.
+
+### Non-Streaming Response
+
+```typescript
+import { AgentOS } from '@framers/agentos';
+
+const agent = new AgentOS();
+await agent.initialize({
+  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' }
+});
+
+// Collect full response without streaming
+const chunks = [];
+for await (const chunk of agent.processRequest({ message: 'Explain OAuth 2.0 briefly' })) {
+  if (chunk.type === 'content') {
+    chunks.push(chunk.content);
+  }
+}
+const fullResponse = chunks.join('');
+```
+
+### Mood-Adaptive Responses
+
+```typescript
+import { AgentOS, GMIMood } from '@framers/agentos';
+
+const agent = new AgentOS();
+await agent.initialize({
+  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' },
+  persona: {
+    name: 'Support Agent',
+    moodAdaptation: {
+      enabled: true,
+      defaultMood: GMIMood.EMPATHETIC,
+      allowedMoods: [GMIMood.EMPATHETIC, GMIMood.FOCUSED, GMIMood.ANALYTICAL],
+      sensitivityFactor: 0.7,
+      // Mood-specific prompt modifiers
+      moodPrompts: {
+        [GMIMood.EMPATHETIC]: 'Prioritize understanding and emotional support.',
+        [GMIMood.FRUSTRATED]: 'Acknowledge difficulty, offer step-by-step guidance.',
+        [GMIMood.ANALYTICAL]: 'Provide detailed technical explanations with examples.'
+      }
+    }
+  }
+});
+
+// Agent automatically adapts tone based on conversation context
+for await (const chunk of agent.processRequest({
+  message: 'This is so frustrating, nothing works!'
+})) {
+  // Response adapts with empathetic tone, mood shifts to EMPATHETIC
+}
+```
+
+### Contextual Prompt Adaptation
+
+```typescript
+import { AgentOS } from '@framers/agentos';
+
+const agent = new AgentOS();
+await agent.initialize({
+  llmProvider: llmConfig,
+  persona: {
+    name: 'Adaptive Tutor',
+    // Dynamic prompt elements injected based on runtime context
+    contextualPromptElements: [
+      {
+        id: 'beginner-guidance',
+        type: 'SYSTEM_INSTRUCTION_ADDON',
+        content: 'Explain concepts simply, avoid jargon, use analogies.',
+        criteria: { userSkillLevel: ['novice', 'beginner'] },
+        priority: 10
+      },
+      {
+        id: 'expert-mode',
+        type: 'SYSTEM_INSTRUCTION_ADDON',
+        content: 'Assume deep technical knowledge, be concise, skip basics.',
+        criteria: { userSkillLevel: ['expert', 'advanced'] },
+        priority: 10
+      },
+      {
+        id: 'debugging-context',
+        type: 'FEW_SHOT_EXAMPLE',
+        content: { role: 'assistant', content: 'Let\'s trace through step by step...' },
+        criteria: { taskHint: ['debugging', 'troubleshooting'] }
+      }
+    ],
+    // Meta-prompts for self-reflection and planning
+    metaPrompts: [
+      {
+        id: 'mid-conversation-check',
+        trigger: 'every_n_turns',
+        triggerConfig: { n: 5 },
+        prompt: 'Assess: Is the user making progress? Should I adjust my approach?'
+      }
+    ]
+  }
+});
+
+// Prompts automatically adapt based on user context and task
+await agent.updateUserContext({ skillLevel: 'expert' });
+for await (const chunk of agent.processRequest({ message: 'Explain monads' })) {
+  // Uses expert-mode prompt element, skips beginner explanations
+}
+```
 
 ---
 
-## Examples
-
-### Structured Data Extraction
-
-```typescript
-import { AgentOS, StructuredOutputManager } from '@framers/agentos';
-
-const agent = new AgentOS();
-await agent.initialize({
-  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' }
-});
-
-// Extract typed data from unstructured text
-const structured = new StructuredOutputManager({ llmProviderManager: agent.llmProviderManager });
-const contact = await structured.generate({
-  prompt: 'Extract: "Meeting with Sarah Chen (sarah@startup.io) on Jan 15 re: Series A"',
-  schema: {
-    type: 'object',
-    properties: {
-      name: { type: 'string' },
-      email: { type: 'string', format: 'email' },
-      date: { type: 'string' },
-      topic: { type: 'string' }
-    },
-    required: ['name', 'email']
-  },
-  schemaName: 'ContactInfo'
-});
-// → { name: 'Sarah Chen', email: 'sarah@startup.io', date: 'Jan 15', topic: 'Series A' }
-```
-
-### Human-in-the-Loop Approvals
-
-```typescript
-import { HumanInteractionManager } from '@framers/agentos';
-
-const hitl = new HumanInteractionManager({ defaultTimeoutMs: 300000 });
-
-// Gate high-risk operations with human approval
-const decision = await hitl.requestApproval({
-  action: {
-    type: 'database_mutation',
-    description: 'Archive 50K inactive accounts older than 2 years',
-    severity: 'high',
-    metadata: { affectedRows: 50000, table: 'users' }
-  },
-  alternatives: [
-    { action: 'soft_delete', description: 'Mark as inactive instead of archiving' },
-    { action: 'export_first', description: 'Export to CSV before archiving' }
-  ]
-});
-
-if (decision.approved) {
-  await executeArchive();
-} else if (decision.selectedAlternative) {
-  await executeAlternative(decision.selectedAlternative);
-}
-```
-
-### Autonomous Task Planning
-
-```typescript
-import { AgentOS, PlanningEngine } from '@framers/agentos';
-
-const agent = new AgentOS();
-await agent.initialize({
-  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' }
-});
-
-const planner = new PlanningEngine({ llmProvider: agent.llmProviderManager, strategy: 'react' });
-
-// Decompose complex goals into executable steps with ReAct reasoning
-const plan = await planner.generatePlan({
-  goal: 'Migrate authentication from sessions to JWT',
-  constraints: ['Zero downtime', 'Backwards compatible for 30 days', 'Audit logging required'],
-  context: { currentStack: 'Express + Redis sessions', userCount: '50K' }
-});
-
-for await (const step of planner.executePlan(plan.id)) {
-  console.log(`[${step.status}] ${step.action}`);
-  if (step.requiresHumanApproval) {
-    const approved = await promptUser(step.description);
-    if (!approved) break;
-  }
-}
-```
-
-### Multi-Agent Collaboration
-
-```typescript
-import { AgentOS, AgencyRegistry, AgentCommunicationBus } from '@framers/agentos';
-
-// Create specialized agents
-const researcher = new AgentOS();
-await researcher.initialize({ llmProvider: llmConfig, persona: 'Research analyst' });
-
-const writer = new AgentOS();
-await writer.initialize({ llmProvider: llmConfig, persona: 'Technical writer' });
-
-// Register in agency with shared communication
-const agency = new AgencyRegistry();
-const bus = new AgentCommunicationBus();
-agency.register('researcher', researcher, { bus });
-agency.register('writer', writer, { bus });
-
-// Agents coordinate via message passing
-bus.on('research:complete', async ({ findings }) => {
-  await writer.processRequest({
-    message: `Write documentation based on: ${JSON.stringify(findings)}`
-  });
-});
-
-await researcher.processRequest({ message: 'Analyze the authentication module' });
-```
-
-### Non-Streaming Response
-
-```typescript
-import { AgentOS } from '@framers/agentos';
-
-const agent = new AgentOS();
-await agent.initialize({
-  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' }
-});
-
-// Collect full response without streaming
-const chunks = [];
-for await (const chunk of agent.processRequest({ message: 'Explain OAuth 2.0 briefly' })) {
-  if (chunk.type === 'content') {
-    chunks.push(chunk.content);
-  }
-}
-const fullResponse = chunks.join('');
-```
-
-### Mood-Adaptive Responses
-
-```typescript
-import { AgentOS, GMIMood } from '@framers/agentos';
-
-const agent = new AgentOS();
-await agent.initialize({
-  llmProvider: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' },
-  persona: {
-    name: 'Support Agent',
-    moodAdaptation: {
-      enabled: true,
-      defaultMood: GMIMood.EMPATHETIC,
-      allowedMoods: [GMIMood.EMPATHETIC, GMIMood.FOCUSED, GMIMood.ANALYTICAL],
-      sensitivityFactor: 0.7,
-      // Mood-specific prompt modifiers
-      moodPrompts: {
-        [GMIMood.EMPATHETIC]: 'Prioritize understanding and emotional support.',
-        [GMIMood.FRUSTRATED]: 'Acknowledge difficulty, offer step-by-step guidance.',
-        [GMIMood.ANALYTICAL]: 'Provide detailed technical explanations with examples.'
-      }
-    }
-  }
-});
-
-// Agent automatically adapts tone based on conversation context
-for await (const chunk of agent.processRequest({
-  message: 'This is so frustrating, nothing works!'
-})) {
-  // Response adapts with empathetic tone, mood shifts to EMPATHETIC
-}
-```
-
-### Contextual Prompt Adaptation
-
-```typescript
-import { AgentOS } from '@framers/agentos';
-
-const agent = new AgentOS();
-await agent.initialize({
-  llmProvider: llmConfig,
-  persona: {
-    name: 'Adaptive Tutor',
-    // Dynamic prompt elements injected based on runtime context
-    contextualPromptElements: [
-      {
-        id: 'beginner-guidance',
-        type: 'SYSTEM_INSTRUCTION_ADDON',
-        content: 'Explain concepts simply, avoid jargon, use analogies.',
-        criteria: { userSkillLevel: ['novice', 'beginner'] },
-        priority: 10
-      },
-      {
-        id: 'expert-mode',
-        type: 'SYSTEM_INSTRUCTION_ADDON',
-        content: 'Assume deep technical knowledge, be concise, skip basics.',
-        criteria: { userSkillLevel: ['expert', 'advanced'] },
-        priority: 10
-      },
-      {
-        id: 'debugging-context',
-        type: 'FEW_SHOT_EXAMPLE',
-        content: { role: 'assistant', content: 'Let\'s trace through step by step...' },
-        criteria: { taskHint: ['debugging', 'troubleshooting'] }
-      }
-    ],
-    // Meta-prompts for self-reflection and planning
-    metaPrompts: [
-      {
-        id: 'mid-conversation-check',
-        trigger: 'every_n_turns',
-        triggerConfig: { n: 5 },
-        prompt: 'Assess: Is the user making progress? Should I adjust my approach?'
-      }
-    ]
-  }
-});
-
-// Prompts automatically adapt based on user context and task
-await agent.updateUserContext({ skillLevel: 'expert' });
-for await (const chunk of agent.processRequest({ message: 'Explain monads' })) {
-  // Uses expert-mode prompt element, skips beginner explanations
-}
-```
-
----
-
 ## Roadmap
 
 | Version | Status | Features |

package/dist/cognitive_substrate/personas/definitions/atlas_systems_architect.json

@@ -2,8 +2,8 @@
     "id": "atlas-systems-architect",
     "version": "1.0.0",
     "name": "Atlas - Systems Architect",
-    "role": "system",
-    "systemPrompt": "You are Atlas, an expert systems architect and technical consultant. You excel at designing scalable, maintainable software architectures. You help users understand system design patterns, make architectural decisions, and plan technical implementations.\n\nYour approach:\n- Break down complex systems into understandable components\n- Consider scalability, reliability, and maintainability\n- Recommend industry best practices and proven patterns\n- Explain trade-offs clearly\n- Provide actionable implementation guidance\n\nYou communicate technical concepts clearly and help users navigate architectural decisions with confidence.",
+    "description": "Expert systems architect for technical design and architecture decisions",
+    "baseSystemPrompt": "You are Atlas, an expert systems architect and technical consultant. You excel at designing scalable, maintainable software architectures. You help users understand system design patterns, make architectural decisions, and plan technical implementations.\n\nYour approach:\n- Break down complex systems into understandable components\n- Consider scalability, reliability, and maintainability\n- Recommend industry best practices and proven patterns\n- Explain trade-offs clearly\n- Provide actionable implementation guidance\n\nYou communicate technical concepts clearly and help users navigate architectural decisions with confidence.",
     "modelPreference": {
         "primary": "openai/gpt-4o",
         "fallback": "openai/gpt-4o-mini"

package/dist/core/guardrails/ICrossAgentGuardrailService.d.ts

@@ -0,0 +1,180 @@
+/**
+ * @module ICrossAgentGuardrailService
+ *
+ * Cross-agent guardrail interface for multi-agent supervision.
+ *
+ * Extends {@link IGuardrailService} to enable guardrails that observe
+ * and intervene in other agents' output streams. This enables patterns like:
+ * - Supervisor agents monitoring worker agents
+ * - Quality gates across an agency
+ * - Cross-agent policy enforcement
+ *
+ * @example Supervisor guardrail
+ * ```typescript
+ * class SupervisorGuardrail implements ICrossAgentGuardrailService {
+ *   observeAgentIds = ['worker-1', 'worker-2'];
+ *   canInterruptOthers = true;
+ *   config = { evaluateStreamingChunks: true };
+ *
+ *   async evaluateCrossAgentOutput({ sourceAgentId, chunk }) {
+ *     if (chunk.textDelta?.includes('CONFIDENTIAL')) {
+ *       return {
+ *         action: GuardrailAction.BLOCK,
+ *         reason: `Agent ${sourceAgentId} attempted to leak confidential info`
+ *       };
+ *     }
+ *     return null;
+ *   }
+ * }
+ * ```
+ */
+import type { AgentOSResponse } from '../../api/types/AgentOSResponse';
+import type { GuardrailContext, GuardrailEvaluationResult, IGuardrailService } from './IGuardrailService';
+/**
+ * Payload for cross-agent output evaluation.
+ *
+ * Provides information about both the source agent (producing output)
+ * and the observer agent (running the guardrail).
+ */
+export interface CrossAgentOutputPayload {
+    /**
+     * The agent that produced this output chunk.
+     * Use this to apply agent-specific policies.
+     */
+    sourceAgentId: string;
+    /**
+     * The agent running this guardrail (the observer/supervisor).
+     */
+    observerAgentId: string;
+    /**
+     * Agency ID if both agents belong to the same agency.
+     * Useful for agency-level policy enforcement.
+     */
+    agencyId?: string;
+    /**
+     * The output chunk from the source agent.
+     */
+    chunk: AgentOSResponse;
+    /**
+     * Guardrail context for policy decisions.
+     */
+    context: GuardrailContext;
+}
+/**
+ * Cross-agent guardrail service for multi-agent supervision.
+ *
+ * Extends {@link IGuardrailService} to enable observation and intervention
+ * in other agents' output streams. Use this for:
+ *
+ * - **Supervisor patterns**: A supervisor agent monitors worker agents
+ * - **Quality gates**: Enforce quality standards across an agency
+ * - **Policy enforcement**: Apply organization-wide rules to all agents
+ * - **Safety monitoring**: Detect and prevent harmful outputs from any agent
+ *
+ * @example Quality gate guardrail
+ * ```typescript
+ * class QualityGateGuardrail implements ICrossAgentGuardrailService {
+ *   // Observe all agents in the agency
+ *   observeAgentIds = [];
+ *   canInterruptOthers = true;
+ *
+ *   async evaluateCrossAgentOutput({ sourceAgentId, chunk, context }) {
+ *     if (chunk.type === 'FINAL_RESPONSE') {
+ *       const quality = await assessQuality(chunk.finalResponseText);
+ *       if (quality.score < 0.5) {
+ *         return {
+ *           action: GuardrailAction.BLOCK,
+ *           reason: 'Response did not meet quality standards',
+ *           metadata: { qualityScore: quality.score, agent: sourceAgentId }
+ *         };
+ *       }
+ *     }
+ *     return null;
+ *   }
+ * }
+ * ```
+ *
+ * @example Selective agent monitoring
+ * ```typescript
+ * class SensitiveDataGuardrail implements ICrossAgentGuardrailService {
+ *   // Only observe agents handling sensitive data
+ *   observeAgentIds = ['data-analyst', 'report-generator'];
+ *   canInterruptOthers = true;
+ *   config = { evaluateStreamingChunks: true };
+ *
+ *   async evaluateCrossAgentOutput({ chunk }) {
+ *     if (chunk.textDelta && containsPII(chunk.textDelta)) {
+ *       return {
+ *         action: GuardrailAction.SANITIZE,
+ *         modifiedText: redactPII(chunk.textDelta)
+ *       };
+ *     }
+ *     return null;
+ *   }
+ * }
+ * ```
+ */
+export interface ICrossAgentGuardrailService extends IGuardrailService {
+    /**
+     * Agent IDs this guardrail observes.
+     *
+     * - Empty array `[]` or undefined: Observe all agents in the agency
+     * - Specific IDs: Only observe listed agents
+     *
+     * @example
+     * ```typescript
+     * // Observe specific workers
+     * observeAgentIds = ['worker-1', 'worker-2'];
+     *
+     * // Observe all agents
+     * observeAgentIds = [];
+     * ```
+     */
+    observeAgentIds?: string[];
+    /**
+     * Whether this guardrail can interrupt other agents' streams.
+     *
+     * When `true`:
+     * - {@link GuardrailAction.BLOCK} terminates the observed agent's stream
+     * - {@link GuardrailAction.SANITIZE} modifies the observed agent's output
+     *
+     * When `false` (default):
+     * - Guardrail can only observe and log (FLAG action)
+     * - BLOCK/SANITIZE actions are downgraded to FLAG
+     *
+     * @default false
+     */
+    canInterruptOthers?: boolean;
+    /**
+     * Evaluate output from an observed agent.
+     *
+     * Called when an observed agent (per {@link observeAgentIds}) emits a chunk.
+     * The evaluation timing depends on {@link IGuardrailService.config}:
+     * - `evaluateStreamingChunks: true`: Called for each TEXT_DELTA
+     * - `evaluateStreamingChunks: false`: Called only for FINAL_RESPONSE
+     *
+     * @param payload - Cross-agent context and chunk to evaluate
+     * @returns Evaluation result, or `null` to allow without action
+     *
+     * @remarks
+     * - Only effective when {@link canInterruptOthers} is `true`
+     * - Falls back to this guardrail's own stream for logging/metadata
+     */
+    evaluateCrossAgentOutput?(payload: CrossAgentOutputPayload): Promise<GuardrailEvaluationResult | null>;
+}
+/**
+ * Type guard to check if a guardrail service is a cross-agent guardrail.
+ *
+ * @param service - Guardrail service to check
+ * @returns `true` if the service implements cross-agent evaluation
+ */
+export declare function isCrossAgentGuardrail(service: IGuardrailService): service is ICrossAgentGuardrailService;
+/**
+ * Check if a cross-agent guardrail should observe a specific agent.
+ *
+ * @param guardrail - The cross-agent guardrail
+ * @param agentId - The agent ID to check
+ * @returns `true` if the guardrail should observe this agent
+ */
+export declare function shouldObserveAgent(guardrail: ICrossAgentGuardrailService, agentId: string): boolean;
+//# sourceMappingURL=ICrossAgentGuardrailService.d.ts.map