@jambonz/schema 0.1.5 → 0.2.1

package/AGENTS.md

@@ -35,7 +35,7 @@ The verb schemas and JSON structure are identical in both modes. The difference
 - **Webhook**: Simple IVR, call routing, voicemail, basic gather-and-respond patterns.
 - **WebSocket**: LLM-powered voice agents, real-time audio streaming, complex conversational flows, anything requiring bidirectional communication, or asynchronous logic, or streaming tts.
 
-**IMPORTANT**: Any application that uses a speech-to-speech verb (`openai_s2s`, `google_s2s`, `deepgram_s2s`, `ultravox_s2s`, `elevenlabs_s2s`, `s2s`, or `pipeline`) MUST use WebSocket transport, not webhooks. These verbs require persistent bidirectional communication for real-time audio and events.
+**IMPORTANT**: Any application that uses a speech-to-speech verb (`openai_s2s`, `google_s2s`, `deepgram_s2s`, `ultravox_s2s`, `elevenlabs_s2s`, `s2s`, or `agent`) MUST use WebSocket transport, not webhooks. These verbs require persistent bidirectional communication for real-time audio and events.
 
 ## Schema
 
@@ -62,10 +62,10 @@ Two tools are available:
 - **gather** — Collect speech (STT) and/or DTMF input. The workhorse for interactive menus and voice input.
 
 ### AI & Real-time
-- **openai_s2s** / **google_s2s** / **deepgram_s2s** / **ultravox_s2s** — Connect the caller to a vendor-specific LLM for real-time voice conversation. These are the **preferred** verbs when the vendor is known. Each handles the full STT→LLM→TTS pipeline with the vendor pre-set.
+- **openai_s2s** / **google_s2s** / **deepgram_s2s** / **ultravox_s2s** — Connect the caller to a vendor-specific LLM for real-time voice conversation. These are the **preferred** verbs when the vendor is known. Each handles the full STT→LLM→TTS flow with the vendor pre-set.
 - **elevenlabs_s2s** — Connect the caller to an ElevenLabs Conversational AI agent. **Unlike other s2s vendors**, ElevenLabs requires a pre-configured `agent_id` (created in the ElevenLabs dashboard) rather than a model and messages. See [ElevenLabs S2S specifics](#elevenlabs-s2s-specifics) below.
 - **s2s** — Generic LLM voice conversation verb. Use only when the vendor is determined at runtime (e.g. from an env var). Requires `vendor` to be specified.
-- **pipeline** — Higher-level voice AI pipeline with integrated turn detection.
+- **agent** — Higher-level voice AI agent with integrated turn detection. Mix-and-match STT, LLM, and TTS vendors.
 - **dialogflow** — Connect the caller to a Google Dialogflow agent (ES, CX, or CES).
 - **stream** — Stream raw audio to a websocket endpoint for custom processing.
 - **transcribe** — Real-time call transcription sent to a webhook.

package/README.md

@@ -4,7 +4,7 @@ JSON Schema definitions and validation for jambonz verb applications.
 
 ## What's Included
 
-- **33 verb schemas** (`verbs/`) -- every jambonz verb (say, gather, dial, openai_s2s, pipeline, etc.)
+- **33 verb schemas** (`verbs/`) -- every jambonz verb (say, gather, dial, openai_s2s, agent, etc.)
 - **42 component schemas** (`components/`) -- shared types (synthesizer, recognizer, target, actionHook, etc.)
 - **32 callback schemas** (`callbacks/`) -- actionHook payload definitions for each verb
 - **AGENTS.md** -- language-agnostic developer guide covering the verb model, transport modes, and protocol

package/callbacks/{pipeline-turn.schema.json → agent-turn.schema.json}

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://jambonz.org/schema/callbacks/pipeline-turn",
-  "title": "Pipeline EventHook Events",
-  "description": "Events sent to the pipeline verb's eventHook during a conversation. These are sent as 'pipeline:event' messages over the WebSocket connection.",
+  "$id": "https://jambonz.org/schema/callbacks/agent-turn",
+  "title": "Agent EventHook Events",
+  "description": "Events sent to the agent verb's eventHook during a conversation. These are sent as 'agent:event' messages over the WebSocket connection.",
   "type": "object",
   "oneOf": [
     {
@@ -84,7 +84,7 @@
     {
       "properties": {
         "type": {
-          "const": "agent_response",
+          "const": "llm_response",
           "description": "Sent when the LLM has finished generating its response for the current turn. Contains the complete response text."
         },
         "response": {

package/components/recognizer.schema.json

@@ -41,9 +41,24 @@
     },
     "hints": {
       "type": "array",
-      "items": { "type": "string" },
-      "description": "An array of words or phrases that the recognizer should favor. Use this to improve accuracy for domain-specific terminology, product names, or proper nouns.",
-      "examples": [["jambonz", "drachtio", "SIP", "WebRTC"]]
+      "items": {
+        "oneOf": [
+          { "type": "string" },
+          {
+            "type": "object",
+            "properties": {
+              "phrase": { "type": "string" },
+              "boost": { "type": "number" }
+            },
+            "required": ["phrase"]
+          }
+        ]
+      },
+      "description": "An array of words or phrases that the recognizer should favor. Each item can be a plain string or an object with 'phrase' and optional 'boost' properties.",
+      "examples": [
+        ["jambonz", "drachtio", "SIP", "WebRTC"],
+        [{"phrase": "jambonz", "boost": 20}, {"phrase": "drachtio", "boost": 10}]
+      ]
     },
     "hintsBoost": {
       "type": "number",

package/docs/guides/session-commands.md

@@ -143,16 +143,16 @@ For any command not covered by a specific method:
 session.injectCommand('commandName', { ...data });
 ```
 
-## Pipeline Update
+## Agent Update
 
-The `updatePipeline()` method sends mid-conversation updates to an active `pipeline` verb. Four operation types are supported:
+The `updateAgent()` method sends mid-conversation updates to an active `agent` verb. Four operation types are supported:
 
 ### Update Instructions
 
 Replace the LLM system prompt while the conversation is in progress:
 
 ```typescript
-session.updatePipeline({
+session.updateAgent({
   type: 'update_instructions',
   instructions: 'You are now a billing support agent. Help the caller with invoice questions.',
 });
@@ -163,7 +163,7 @@ session.updatePipeline({
 Append messages to the LLM conversation history (e.g. CRM data retrieved after the call started):
 
 ```typescript
-session.updatePipeline({
+session.updateAgent({
   type: 'inject_context',
   messages: [
     { role: 'system', content: 'Customer account #12345: Gold tier, 3 open tickets.' },
@@ -176,7 +176,7 @@ session.updatePipeline({
 Replace the tool set available to the LLM:
 
 ```typescript
-session.updatePipeline({
+session.updateAgent({
   type: 'update_tools',
   tools: [
     {
@@ -193,24 +193,24 @@ session.updatePipeline({
 
 ### Generate Reply
 
-Prompt the LLM to generate a new response. If the pipeline is not idle, the request is queued and executes when the current turn completes. Use `interrupt: true` to cancel the current response and generate immediately.
+Prompt the LLM to generate a new response. If the agent is not idle, the request is queued and executes when the current turn completes. Use `interrupt: true` to cancel the current response and generate immediately.
 
 ```typescript
 // Simple prompt
-session.updatePipeline({
+session.updateAgent({
   type: 'generate_reply',
   user_input: 'The customer just entered their account number: 12345',
 });
 
 // With one-shot instructions
-session.updatePipeline({
+session.updateAgent({
   type: 'generate_reply',
   user_input: 'Customer is asking about refunds',
   instructions: 'Be empathetic and offer a 20% discount before processing a refund.',
 });
 
 // Interrupt current response and generate a new one
-session.updatePipeline({
+session.updateAgent({
   type: 'generate_reply',
   user_input: 'Urgent: supervisor override',
   interrupt: true,
@@ -219,7 +219,7 @@ session.updatePipeline({
 
 ## LLM Tool Output
 
-When using the `pipeline` verb with a `toolHook`, tool call requests arrive as events. Return results with:
+When using the `agent` verb with a `toolHook`, tool call requests arrive as events. Return results with:
 
 ```typescript
 session.on('/tool-hook', (evt: Record<string, any>) => {
@@ -237,7 +237,7 @@ The result is stringified and fed back to the LLM as the tool response.
 
 ## Building a Cascaded Voice AI Agent
 
-The **pipeline** verb is the simplest way to build a voice AI agent — jambonz manages everything. But when you need full control over the LLM interaction (custom tool handling, conversation history management, multiple LLM providers, etc.), build a **cascaded agent**: your app handles STT transcripts and LLM calls directly, piping responses back via TTS token streaming.
+The **agent** verb is the simplest way to build a voice AI agent — jambonz manages everything. But when you need full control over the LLM interaction (custom tool handling, conversation history management, multiple LLM providers, etc.), build a **cascaded agent**: your app handles STT transcripts and LLM calls directly, piping responses back via TTS token streaming.
 
 ### Architecture
 
@@ -257,9 +257,9 @@ User speaks again → bargeIn fires → repeat
 
 The key mechanism is the `bargeIn` actionHook on the `config` verb. When enabled with `sticky: true`, it persists across all verbs. Whenever the caller speaks, the `/speech-detected` hook fires with the speech transcript — even while TTS is playing (which triggers an interruption). Your app then calls the LLM and streams the response back.
 
-### When to Use Cascaded vs Pipeline
+### When to Use Cascaded vs Agent
 
-| | Pipeline verb | Cascaded agent |
+| | Agent verb | Cascaded agent |
 |---|---|---|
 | **STT/LLM/TTS** | jambonz orchestrates all three | App owns the LLM; jambonz handles STT and TTS |
 | **Turn detection** | Built-in (Krisp or STT-native) | App manages via bargeIn actionHook |

package/docs/verbs/{pipeline.md → agent.md}

@@ -1,8 +1,8 @@
 ## Overview
 
-The pipeline verb orchestrates a complete voice AI agent by wiring together three separate components — STT, LLM, and TTS — with integrated turn detection. Unlike the s2s verbs (where a single vendor handles everything), pipeline lets you mix and match: e.g. Deepgram for STT, Anthropic for the LLM, and Cartesia for TTS.
+The agent verb orchestrates a complete voice AI agent by wiring together three separate components — STT, LLM, and TTS — with integrated turn detection. Unlike the s2s verbs (where a single vendor handles everything), the agent verb lets you mix and match: e.g. Deepgram for STT, Anthropic for the LLM, and Cartesia for TTS.
 
-Pipeline manages the full conversational turn cycle:
+The agent manages the full conversational turn cycle:
 1. User speaks → STT produces a transcript
 2. Turn detection decides the user is done speaking
 3. Transcript is sent to the LLM
@@ -12,7 +12,7 @@ Pipeline manages the full conversational turn cycle:
 
 ## Turn detection
 
-The `turnDetection` property controls how the pipeline decides the user has finished speaking.
+The `turnDetection` property controls how the agent decides the user has finished speaking.
 
 **`"stt"` (default)** — Uses the STT vendor's native end-of-utterance signal. For most vendors this is silence-based. Some vendors have smarter built-in turn detection:
 - **deepgramflux** — Acoustic + semantic turn detection (Deepgram's "Flux" model)
@@ -105,15 +105,15 @@ The `eventHook` receives real-time events during the conversation. In WebSocket
 | Event type | Description | Key fields |
 |---|---|---|
 | `user_transcript` | User speech recognized | `transcript` |
-| `agent_response` | Assistant reply text | `response` |
+| `llm_response` | Assistant reply text | `response` |
 | `user_interruption` | User barged in | — |
 | `turn_end` | End-of-turn summary | `transcript`, `response`, `interrupted`, `latency` |
 
-The `turn_end` event is the most useful for observability. It includes per-component latency metrics (STT, LLM, TTS) in milliseconds. See the `callback:pipeline-turn` schema for the full payload structure.
+The `turn_end` event is the most useful for observability. It includes per-component latency metrics (STT, LLM, TTS) in milliseconds. See the `callback:agent-turn` schema for the full payload structure.
 
 ## toolHook (function calling)
 
-When the LLM requests a tool/function call, the pipeline sends a request to the `toolHook` with:
+When the LLM requests a tool/function call, the agent sends a request to the `toolHook` with:
 
 ```json
 {
@@ -131,11 +131,11 @@ The `arguments` field is already parsed (an object, not a JSON string).
 
 ## MCP servers (external tools)
 
-Instead of (or in addition to) defining tools inline via `llmOptions.tools` and handling them with `toolHook`, you can connect to external MCP servers. The pipeline connects to each server at startup via SSE transport, discovers available tools, and makes them available to the LLM alongside any inline tools.
+Instead of (or in addition to) defining tools inline via `llmOptions.tools` and handling them with `toolHook`, you can connect to external MCP servers. The agent connects to each server at startup via SSE transport, discovers available tools, and makes them available to the LLM alongside any inline tools.
 
 ```json
 {
-  "verb": "pipeline",
+  "verb": "agent",
   "mcpServers": [
     {
       "url": "https://livescoremcp.com/sse"
@@ -155,7 +155,7 @@ Instead of (or in addition to) defining tools inline via `llmOptions.tools` and
 }
 ```
 
-The [LiveScore MCP server](https://livescoremcp.com/) is a free, public MCP server that exposes tools for live football scores, fixtures, team stats, and player data. The pipeline discovers these tools automatically at startup — no need to define tool schemas in `llmOptions.tools`. A caller can simply ask "what football matches are on right now?" and the LLM will use the `get_live_scores` tool to fetch real-time data.
+The [LiveScore MCP server](https://livescoremcp.com/) is a free, public MCP server that exposes tools for live football scores, fixtures, team stats, and player data. The agent discovers these tools automatically at startup — no need to define tool schemas in `llmOptions.tools`. A caller can simply ask "what football matches are on right now?" and the LLM will use the `get_live_scores` tool to fetch real-time data.
 
 If an MCP server requires authentication, pass credentials in the `auth` property:
 
@@ -172,13 +172,13 @@ If an MCP server requires authentication, pass credentials in the `auth` propert
 }
 ```
 
-**How tool dispatch works**: When the LLM requests a tool call, the pipeline checks MCP servers first. If the tool name matches one discovered from an MCP server, the call is dispatched there directly and the result is fed back to the LLM. If no MCP server provides the tool, it falls through to the `toolHook` webhook. You can use both MCP servers and `toolHook` together — MCP handles the tools it knows about, and `toolHook` handles the rest.
+**How tool dispatch works**: When the LLM requests a tool call, the agent checks MCP servers first. If the tool name matches one discovered from an MCP server, the call is dispatched there directly and the result is fed back to the LLM. If no MCP server provides the tool, it falls through to the `toolHook` webhook. You can use both MCP servers and `toolHook` together — MCP handles the tools it knows about, and `toolHook` handles the rest.
 
-**TypeScript example** — a pipeline agent with the LiveScore MCP server:
+**TypeScript example** — an agent with the LiveScore MCP server:
 
 ```typescript
 session
-  .pipeline({
+  .agent({
     stt: { vendor: 'deepgram', language: 'en-US' },
     tts: { vendor: 'cartesia', voice: 'sonic-english' },
     llm: {
@@ -196,18 +196,18 @@ session
       // { url: 'https://mcp.example.com/sse', auth: { apiKey: 'your-key' } },
     ],
     turnDetection: 'krisp',
-    actionHook: '/pipeline-complete',
+    actionHook: '/agent-complete',
   })
   .send();
 ```
 
 ## Mid-conversation updates
 
-The pipeline supports asynchronous updates while a conversation is in progress. These let you change the agent's behavior, inject new context, modify available tools, or trigger a new LLM response — without interrupting the current verb stack.
+The agent supports asynchronous updates while a conversation is in progress. These let you change the agent's behavior, inject new context, modify available tools, or trigger a new LLM response — without interrupting the current verb stack.
 
 Updates can be sent via:
-- **WebSocket**: `session.updatePipeline(data)` (sends a `pipeline:update` command)
-- **REST API**: `client.calls.updatePipeline(callSid, data)` (sends `pipeline_update` in the PUT body)
+- **WebSocket**: `session.updateAgent(data)` (sends an `agent:update` command)
+- **REST API**: `client.calls.updateAgent(callSid, data)` (sends `agent_update` in the PUT body)
 
 ### update_instructions
 
@@ -215,13 +215,13 @@ Replace the LLM system prompt mid-conversation. Useful when the conversation tra
 
 ```typescript
 // WebSocket
-session.updatePipeline({
+session.updateAgent({
   type: 'update_instructions',
   instructions: 'You are now a billing support agent. Help the caller with invoice questions.',
 });
 
 // REST
-await client.calls.updatePipeline(callSid, {
+await client.calls.updateAgent(callSid, {
   type: 'update_instructions',
   instructions: 'You are now a billing support agent. Help the caller with invoice questions.',
 });
@@ -232,7 +232,7 @@ await client.calls.updatePipeline(callSid, {
 Append messages to the LLM conversation history. Useful for injecting CRM data, call notes, or other context retrieved after the call started.
 
 ```typescript
-session.updatePipeline({
+session.updateAgent({
   type: 'inject_context',
   messages: [
     { role: 'system', content: 'Customer account #12345: Gold tier, 3 open tickets.' },
@@ -245,7 +245,7 @@ session.updatePipeline({
 Replace the tool set available to the LLM. The new tools take effect on the next LLM turn.
 
 ```typescript
-session.updatePipeline({
+session.updateAgent({
   type: 'update_tools',
   tools: [
     {
@@ -262,26 +262,26 @@ session.updatePipeline({
 
 ### generate_reply
 
-Prompt the LLM to generate a new response. If the pipeline is currently idle, the prompt executes immediately. If the pipeline is busy (e.g. the assistant is speaking), the request is queued and executes when the current turn completes.
+Prompt the LLM to generate a new response. If the agent is currently idle, the prompt executes immediately. If the agent is busy (e.g. the assistant is speaking), the request is queued and executes when the current turn completes.
 
 Use `interrupt: true` to cancel the current response and generate immediately — useful for supervisor overrides or urgent context changes.
 
 ```typescript
 // Simple prompt
-session.updatePipeline({
+session.updateAgent({
   type: 'generate_reply',
   user_input: 'The customer just entered their account number: 12345',
 });
 
 // With one-shot instructions
-session.updatePipeline({
+session.updateAgent({
   type: 'generate_reply',
   user_input: 'Customer is asking about refunds',
   instructions: 'Be empathetic and offer a 20% discount before processing a refund.',
 });
 
 // Interrupt current response
-session.updatePipeline({
+session.updateAgent({
   type: 'generate_reply',
   user_input: 'Urgent: supervisor override',
   interrupt: true,
@@ -326,11 +326,11 @@ For Anthropic models, use `"vendor": "anthropic"` and structure messages accordi
 
 ## Greeting
 
-By default (`greeting: true`), the pipeline prompts the LLM to generate an initial greeting before the user speaks. Set `greeting: false` if you want the agent to wait silently for the user to speak first.
+By default (`greeting: true`), the agent prompts the LLM to generate an initial greeting before the user speaks. Set `greeting: false` if you want the agent to wait silently for the user to speak first.
 
 ## Complete example (TypeScript)
 
-A pipeline voice agent using Deepgram STT, OpenAI LLM, and Cartesia TTS with Krisp turn detection. Exposes multiple endpoints with different STT/TTS combinations:
+A voice agent using Deepgram STT, OpenAI LLM, and Cartesia TTS with Krisp turn detection. Exposes multiple endpoints with different STT/TTS combinations:
 
 ```typescript
 import * as http from 'node:http';
@@ -354,19 +354,19 @@ function handleSession(session: Session) {
   const model = session.data.env_vars?.OPENAI_MODEL || 'gpt-4.1-mini';
   const systemPrompt = session.data.env_vars?.SYSTEM_PROMPT || envVars.SYSTEM_PROMPT.default;
 
-  session.on('/pipeline-event', (evt: Record<string, unknown>) => {
+  session.on('/agent-event', (evt: Record<string, unknown>) => {
     if (evt.type === 'turn_end') {
       const { transcript, response, interrupted, latency } = evt as Record<string, unknown>;
       console.log('turn_end', JSON.stringify({ transcript, response, interrupted, latency }, null, 2));
     }
   });
 
-  session.on('/pipeline-complete', () => {
+  session.on('/agent-complete', () => {
     session.hangup().reply();
   });
 
   session
-    .pipeline({
+    .agent({
       stt: {
         vendor: 'deepgram',
         language: 'multi',
@@ -386,8 +386,8 @@ function handleSession(session: Session) {
       turnDetection: 'krisp',
       earlyGeneration: true,
       bargeIn: { enable: true },
-      eventHook: '/pipeline-event',
-      actionHook: '/pipeline-complete',
+      eventHook: '/agent-event',
+      actionHook: '/agent-complete',
     })
     .send();
 }
@@ -426,19 +426,19 @@ function handleSession(session) {
   const model = session.data.env_vars?.OPENAI_MODEL || 'gpt-4.1-mini';
   const systemPrompt = session.data.env_vars?.SYSTEM_PROMPT || envVars.SYSTEM_PROMPT.default;
 
-  session.on('/pipeline-event', (evt) => {
+  session.on('/agent-event', (evt) => {
     if (evt.type === 'turn_end') {
       const { transcript, response, interrupted, latency } = evt;
       console.log('turn_end', JSON.stringify({ transcript, response, interrupted, latency }, null, 2));
     }
   });
 
-  session.on('/pipeline-complete', () => {
+  session.on('/agent-complete', () => {
     session.hangup().reply();
   });
 
   session
-    .pipeline({
+    .agent({
       stt: {
         vendor: 'deepgram',
         language: 'multi',
@@ -458,8 +458,8 @@ function handleSession(session) {
       turnDetection: 'krisp',
       earlyGeneration: true,
       bargeIn: { enable: true },
-      eventHook: '/pipeline-event',
-      actionHook: '/pipeline-complete',
+      eventHook: '/agent-event',
+      actionHook: '/agent-complete',
     })
     .send();
 }

package/jambonz-app.schema.json

@@ -28,7 +28,7 @@
         { "$ref": "verbs/deepgram_s2s" },
         { "$ref": "verbs/ultravox_s2s" },
         { "$ref": "verbs/dialogflow" },
-        { "$ref": "verbs/pipeline" },
+        { "$ref": "verbs/agent" },
         { "$ref": "verbs/conference" },
         { "$ref": "verbs/transcribe" },
         { "$ref": "verbs/enqueue" },

package/lib/validator.js

@@ -88,9 +88,8 @@ function validateVerb(name, data, logger) {
   if (!valid) {
     const errors = validate.errors || [];
     const details = errors.map((e) => {
-      const path = e.instancePath || '/';
-      const prop = path.split('/').filter(Boolean).pop() || '(root)';
-      let msg = `property '${prop}': ${e.message}`;
+      const path = e.instancePath || '(root)';
+      let msg = `'${path}': ${e.message}`;
       if (e.params) {
         if (e.params.type) msg += ` (expected ${e.params.type})`;
         if (e.params.allowedValues) msg += ` (allowed: ${e.params.allowedValues.join(', ')})`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jambonz/schema",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "description": "JSON Schema definitions and validation for jambonz verb applications",
   "main": "index.js",
   "scripts": {

package/verbs/{pipeline.schema.json → agent.schema.json}

@@ -1,13 +1,13 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://jambonz.org/schema/verbs/pipeline",
+  "$id": "https://jambonz.org/schema/verbs/agent",
   "minVersion": "10.1.0",
-  "title": "Pipeline",
-  "description": "Configures a complete STT → LLM → TTS voice AI pipeline with integrated turn detection. Provides a higher-level abstraction than manually orchestrating the individual components. Optimized for building voice AI agents with proper turn-taking behavior.",
+  "title": "Agent",
+  "description": "Configures a complete voice AI agent by wiring together STT → LLM → TTS with integrated turn detection. Provides a higher-level abstraction than manually orchestrating the individual components. Optimized for building voice AI agents with proper turn-taking behavior.",
   "type": "object",
   "properties": {
     "verb": {
-      "const": "pipeline"
+      "const": "agent"
     },
     "id": {
       "type": "string",
@@ -15,11 +15,11 @@
     },
     "stt": {
       "$ref": "../components/recognizer",
-      "description": "Speech-to-text configuration for the pipeline."
+      "description": "Speech-to-text configuration for the agent."
     },
     "tts": {
       "$ref": "../components/synthesizer",
-      "description": "Text-to-speech configuration for the pipeline."
+      "description": "Text-to-speech configuration for the agent."
     },
     "turnDetection": {
       "oneOf": [
@@ -53,7 +53,7 @@
         }
       ],
       "default": "stt",
-      "description": "Turn detection strategy. Controls when the pipeline decides the user has finished speaking. STT vendors with native turn-taking (deepgramflux, assemblyai, speechmatics) always use their built-in detection regardless of this setting."
+      "description": "Turn detection strategy. Controls when the agent decides the user has finished speaking. STT vendors with native turn-taking (deepgramflux, assemblyai, speechmatics) always use their built-in detection regardless of this setting."
     },
     "bargeIn": {
       "type": "object",
@@ -86,16 +86,16 @@
     },
     "llm": {
       "type": "object",
-      "description": "LLM configuration for the pipeline. See the 'llm' verb schema for details.",
+      "description": "LLM configuration for the agent. See the 'llm' verb schema for details.",
       "additionalProperties": true
     },
     "actionHook": {
       "$ref": "../components/actionHook",
-      "description": "A webhook invoked when the pipeline ends."
+      "description": "A webhook invoked when the agent ends."
     },
     "eventHook": {
       "$ref": "../components/actionHook",
-      "description": "A webhook invoked for pipeline events. Receives event types: 'user_transcript' (user speech recognized), 'agent_response' (assistant reply), 'user_interruption' (barge-in detected), and 'turn_end' (end-of-turn summary with transcript, response, and latency metrics)."
+      "description": "A webhook invoked for agent events. Receives event types: 'user_transcript' (user speech recognized), 'llm_response' (assistant reply), 'user_interruption' (barge-in detected), and 'turn_end' (end-of-turn summary with transcript, response, and latency metrics)."
     },
     "toolHook": {
       "$ref": "../components/actionHook",
@@ -171,7 +171,7 @@
         },
         "required": ["url"]
       },
-      "description": "External MCP servers that provide tools to the LLM. The pipeline connects at startup via SSE, discovers available tools, and makes them callable by the LLM."
+      "description": "External MCP servers that provide tools to the LLM. The agent connects at startup via SSE, discovers available tools, and makes them callable by the LLM."
     }
   },
   "required": [
@@ -179,7 +179,7 @@
   ],
   "examples": [
     {
-      "verb": "pipeline",
+      "verb": "agent",
       "stt": {
         "vendor": "deepgram",
         "language": "en-US"
@@ -201,10 +201,10 @@
         }
       },
       "turnDetection": "stt",
-      "actionHook": "/pipeline-complete"
+      "actionHook": "/agent-complete"
     },
     {
-      "verb": "pipeline",
+      "verb": "agent",
       "stt": {
         "vendor": "deepgram",
         "language": "en-US"
@@ -234,7 +234,7 @@
         "minSpeechDuration": 0.3,
         "sticky": false
       },
-      "actionHook": "/pipeline-complete"
+      "actionHook": "/agent-complete"
     }
   ]
 }