Class SingleAgentClient

Internal single-agent client implementation

This is an internal implementation detail used by AgentClient and ADCPMultiAgentClient. External users should use AdCPClient (alias for ADCPMultiAgentClient) instead.

Key features:

🔒 Full type safety for all ADCP tasks
💬 Conversation management with context preservation
🔄 Input handler pattern for clarifications
⏱️ Timeout and retry support
🐛 Debug logging and observability
🎯 Works with both MCP and A2A protocols

Constructors

constructor

new SingleAgentClient(
agent: AgentConfig,
config?: SingleAgentClientConfig,
): SingleAgentClient
Parameters
- agent: AgentConfig
- config: SingleAgentClientConfig = {}
Returns SingleAgentClient
- Defined in src/lib/core/SingleAgentClient.ts:180

Methods

handleWebhook

handleWebhook(
    payload: MCPWebhookPayload | Task | TaskStatusUpdateEvent,
    taskType: string,
    operationId: string,
    signature?: string,
    timestamp?: string | number,
): Promise<boolean>
Handle webhook from agent (async task status updates and completions)

Accepts webhook payloads from both MCP and A2A protocols:
1. MCP: MCPWebhookPayload envelope with AdCP data in .result field
2. A2A: Native Task/TaskStatusUpdateEvent with AdCP data in either:
  - status.message.parts[].data (for status updates)
  - artifacts (for task completion, per A2A spec)
The method normalizes both formats so handlers receive the unwrapped AdCP response data (AdCPAsyncResponseData), not the raw protocol structure.
Parameters
- payload: MCPWebhookPayload | Task | TaskStatusUpdateEvent
  Protocol-specific webhook payload (MCPWebhookPayload | Task | TaskStatusUpdateEvent)
- taskType: string
  Task type (e.g create_media_buy) from url param or url part of the webhook delivery
- operationId: string
  Operation id (e.g used for client app to track the operation) from the param or url part of the webhook delivery
- Optionalsignature: string
  X-ADCP-Signature header (format: "sha256=...")
- Optionaltimestamp: string | number
  X-ADCP-Timestamp header (Unix timestamp)
Returns Promise<boolean>
Whether webhook was handled successfully
Example
```
app.post('/webhook/:taskType', async (req, res) => {
  const signature = req.headers['x-adcp-signature'];
  const timestamp = req.headers['x-adcp-timestamp'];

  try {
    const handled = await client.handleWebhook(req.body, signature, timestamp, req.params.taskType);
    res.status(200).json({ received: handled });
  } catch (error) {
    res.status(401).json({ error: error.message });
  }
});
```
- Defined in src/lib/core/SingleAgentClient.ts:570

getWebhookUrl

getWebhookUrl(taskType: string, operationId: string): string

Generate webhook URL using macro substitution

Parameters

taskType: string
Type of task (e.g., 'get_products', 'media_buy_delivery')
operationId: string
Operation ID for this request

Returns string

Full webhook URL with macros replaced

Example

// With template: "https://myapp.com/webhook/{task_type}/{agent_id}/{operation_id}"
const webhookUrl = client.getWebhookUrl('sync_creatives', 'op_123');
// Returns: https://myapp.com/webhook/sync_creatives/agent_x/op_123

// With template: "https://myapp.com/webhook?agent={agent_id}&op={operation_id}"
const webhookUrl = client.getWebhookUrl('sync_creatives', 'op_123');
// Returns: https://myapp.com/webhook?agent=agent_x&op=op_123

createWebhookHandler

createWebhookHandler(): (req: any, res: any) => Promise<void>
Create an HTTP webhook handler that automatically verifies signatures

This helper creates a standard HTTP handler (Express/Next.js/etc.) that:
- Extracts X-ADCP-Signature and X-ADCP-Timestamp headers
- Verifies HMAC signature (if webhookSecret configured)
- Validates timestamp freshness
- Calls handleWebhook() with proper error handling
Returns (req: any, res: any) => Promise<void>
HTTP handler function compatible with Express, Next.js, etc.
Example: Express
```
const client = new ADCPClient(agent, {
  webhookSecret: 'your-secret-key',
  handlers: {
    onSyncCreativesStatusChange: async (result) => {
      console.log('Creative synced:', result);
    }
  }
});

app.post('/webhook', client.createWebhookHandler());
```
Example: Next.js API Route
```
export default client.createWebhookHandler();
```
- Defined in src/lib/core/SingleAgentClient.ts:785

verifyWebhookSignature

verifyWebhookSignature(
    payload: any,
    signature: string,
    timestamp: string | number,
): boolean
Verify webhook signature using HMAC-SHA256 per AdCP PR #86 spec

Signature format: sha256={hex_signature} Message format: {timestamp}.{json_payload}
Parameters
- payload: any
  Webhook payload object
- signature: string
  X-ADCP-Signature header value (format: "sha256=...")
- timestamp: string | number
  X-ADCP-Timestamp header value (Unix timestamp)
Returns boolean
true if signature is valid
- Defined in src/lib/core/SingleAgentClient.ts:830

getProducts

getProducts(
    params: GetProductsRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<GetProductsResponse>>
Discover available advertising products
Parameters
- params: GetProductsRequest
  Product discovery parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<GetProductsResponse>>
Example
```
const products = await client.getProducts(
  {
    brief: 'Premium coffee brands for millennials',
    promoted_offering: 'Artisan coffee blends'
  },
  (context) => {
    if (context.inputRequest.field === 'budget') return 50000;
    return context.deferToHuman();
  }
);
```
- Defined in src/lib/core/SingleAgentClient.ts:1055

listCreativeFormats

listCreativeFormats(
    params: ListCreativeFormatsRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<ListCreativeFormatsResponse>>
List available creative formats
Parameters
- params: ListCreativeFormatsRequest
  Format listing parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<ListCreativeFormatsResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1076

createMediaBuy

createMediaBuy(
    params: CreateMediaBuyRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<CreateMediaBuyResponse>>
Create a new media buy
Parameters
- params: CreateMediaBuyRequest
  Media buy creation parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<CreateMediaBuyResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1097

updateMediaBuy

updateMediaBuy(
    params: UpdateMediaBuyRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<UpdateMediaBuyResponse>>
Update an existing media buy
Parameters
- params: UpdateMediaBuyRequest
  Media buy update parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<UpdateMediaBuyResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1152

syncCreatives

syncCreatives(
    params: SyncCreativesRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<SyncCreativesResponse>>
Sync creative assets
Parameters
- params: SyncCreativesRequest
  Creative sync parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<SyncCreativesResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1173

listCreatives

listCreatives(
    params: ListCreativesRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<ListCreativesResponse>>
List creative assets
Parameters
- params: ListCreativesRequest
  Creative listing parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<ListCreativesResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1194

previewCreative

previewCreative(
    params: PreviewCreativeRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<PreviewCreativeResponse>>
Preview a creative
Parameters
- params: PreviewCreativeRequest
  Preview creative parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<PreviewCreativeResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1215

getMediaBuyDelivery

getMediaBuyDelivery(
    params: GetMediaBuyDeliveryRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<GetMediaBuyDeliveryResponse>>
Get media buy delivery information
Parameters
- params: GetMediaBuyDeliveryRequest
  Delivery information parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<GetMediaBuyDeliveryResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1236

providePerformanceFeedback

providePerformanceFeedback(
    params: ProvidePerformanceFeedbackRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<ProvidePerformanceFeedbackResponse>>
Provide performance feedback
Parameters
- params: ProvidePerformanceFeedbackRequest
  Performance feedback parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<ProvidePerformanceFeedbackResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1257

getSignals

getSignals(
    params: GetSignalsRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<GetSignalsResponse>>
Get audience signals
Parameters
- params: GetSignalsRequest
  Signals request parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<GetSignalsResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1280

activateSignal

activateSignal(
    params: ActivateSignalRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<ActivateSignalResponse>>
Activate audience signals
Parameters
- params: ActivateSignalRequest
  Signal activation parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<ActivateSignalResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1301

getAdcpCapabilities

getAdcpCapabilities(
    params: GetAdCPCapabilitiesRequest,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<GetAdCPCapabilitiesResponse>>
Get AdCP capabilities
Parameters
- params: GetAdCPCapabilitiesRequest
  Capabilities request parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<GetAdCPCapabilitiesResponse>>
- Defined in src/lib/core/SingleAgentClient.ts:1324

executeTask

executeTask<T = any>(
    taskName: string,
    params: any,
    inputHandler?: InputHandler,
    options?: TaskOptions,
): Promise<TaskResult<T>>
Execute any task by name with type safety
Type Parameters
- T = any
Parameters
- taskName: string
  Name of the task to execute
- params: any
  Task parameters
- OptionalinputHandler: InputHandler
  Handler for clarification requests
- Optionaloptions: TaskOptions
  Task execution options
Returns Promise<TaskResult<T>>
Example
```
const result = await client.executeTask(
  'get_products',
  { brief: 'Coffee brands' },
  handler
);
```
- Defined in src/lib/core/SingleAgentClient.ts:1358

resumeDeferredTask

resumeDeferredTask<T = any>(
token: string,
inputHandler: InputHandler,
): Promise<TaskResult<T>>
Resume a deferred task using its token
Type Parameters
- T = any
Parameters
- token: string
  Deferred task token
- inputHandler: InputHandler
  Handler to provide the missing input
Returns Promise<TaskResult<T>>
Example
```
try {
  await client.createMediaBuy(params, handler);
} catch (error) {
  if (error instanceof DeferredTaskError) {
    // Get human input and resume
    const result = await client.resumeDeferredTask(
      error.token,
      (context) => humanProvidedValue
    );
  }
}
```
- Defined in src/lib/core/SingleAgentClient.ts:1391

continueConversation

continueConversation<T = any>(
    message: string,
    contextId: string,
    inputHandler?: InputHandler,
): Promise<TaskResult<T>>
Continue an existing conversation with the agent
Type Parameters
- T = any
Parameters
- message: string
  Message to send to the agent
- contextId: string
  Conversation context ID to continue
- OptionalinputHandler: InputHandler
  Handler for any clarification requests
Returns Promise<TaskResult<T>>
Example
```
const agent = new ADCPClient(config);
const initial = await agent.getProducts({ brief: 'Tech products' });

// Continue the conversation
const refined = await agent.continueConversation(
  'Focus only on laptops under $1000',
  initial.metadata.taskId
);
```
- Defined in src/lib/core/SingleAgentClient.ts:1419

getConversationHistory

getConversationHistory(taskId: string): undefined | Message[]
Get conversation history for a task
Parameters
- taskId: string
Returns undefined | Message[]
- Defined in src/lib/core/SingleAgentClient.ts:1431

clearConversationHistory

clearConversationHistory(taskId: string): void
Clear conversation history for a task
Parameters
- taskId: string
Returns void
- Defined in src/lib/core/SingleAgentClient.ts:1438

getAgent

getAgent(): AgentConfig
Get the agent configuration with normalized protocol

Returns the agent config with:
- Protocol normalized (e.g., .well-known URLs switch to A2A)
- If canonical URL has been resolved, agent_uri will be the canonical URL
For guaranteed canonical URL, use getResolvedAgent() instead.
Returns AgentConfig
- Defined in src/lib/core/SingleAgentClient.ts:1453

getResolvedAgent

getResolvedAgent(): Promise<AgentConfig>
Get the fully resolved agent configuration

This async method ensures the agent config has the canonical URL resolved:
- For A2A: Fetches the agent card and uses its 'url' field
- For MCP: Performs endpoint discovery
Returns Promise<AgentConfig>
Promise resolving to agent config with canonical URL
- Defined in src/lib/core/SingleAgentClient.ts:1477

getAgentId

getAgentId(): string
Get the agent ID

Returns string
- Defined in src/lib/core/SingleAgentClient.ts:1485

getAgentName

getAgentName(): string
Get the agent name

Returns string
- Defined in src/lib/core/SingleAgentClient.ts:1492

getProtocol

getProtocol(): "mcp" | "a2a"
Get the agent protocol (may be normalized from original config)

Returns "mcp" | "a2a"
- Defined in src/lib/core/SingleAgentClient.ts:1499

getCanonicalUrl

getCanonicalUrl(): string
Get the canonical base URL for this agent

Returns the canonical URL if already resolved, or computes it synchronously from the configured URL. For the most accurate canonical URL (especially for A2A where the agent card contains the authoritative URL), use resolveCanonicalUrl() first.

The canonical URL is:
- For A2A: The 'url' field from the agent card (if resolved), or base URL with /.well-known/agent-card.json stripped
- For MCP: The discovered endpoint with /mcp stripped
Returns string
The canonical base URL (synchronous, may not be fully resolved)
- Defined in src/lib/core/SingleAgentClient.ts:1517

resolveCanonicalUrl

resolveCanonicalUrl(): Promise<string>
Resolve and return the canonical base URL for this agent

This async method ensures the canonical URL is properly resolved:
- For A2A: Fetches the agent card and uses its 'url' field
- For MCP: Performs endpoint discovery and strips /mcp suffix
The result is cached, so subsequent calls are fast.
Returns Promise<string>
Promise resolving to the canonical base URL
- Defined in src/lib/core/SingleAgentClient.ts:1538

isSameAgent

isSameAgent(other: AgentConfig | SingleAgentClient): boolean
Check if this agent is the same as another agent

Compares agents by their canonical base URLs. Two agents are considered the same if they have the same canonical URL, regardless of:
- Protocol (MCP vs A2A)
- URL format (with/without /mcp, with/without /.well-known/agent-card.json)
- Trailing slashes
Parameters
- other: AgentConfig | SingleAgentClient
  Another agent configuration or SingleAgentClient to compare
Returns boolean
true if agents have the same canonical URL
- Defined in src/lib/core/SingleAgentClient.ts:1564

isSameAgentResolved

isSameAgentResolved(other: AgentConfig | SingleAgentClient): Promise<boolean>
Async version of isSameAgent that resolves canonical URLs first

This provides more accurate comparison for A2A agents since it fetches the agent card to get the authoritative canonical URL.
Parameters
- other: AgentConfig | SingleAgentClient
  Another agent configuration or SingleAgentClient to compare
Returns Promise<boolean>
Promise resolving to true if agents have the same canonical URL
- Defined in src/lib/core/SingleAgentClient.ts:1586

getActiveTasks

getActiveTasks(): TaskState[]
Get active tasks for this agent

Returns TaskState[]
- Defined in src/lib/core/SingleAgentClient.ts:1603

listTasks

listTasks(): Promise<TaskInfo[]>
List all tasks for this agent with detailed information

Returns Promise<TaskInfo[]>
Promise resolving to array of task information
Example
```
const tasks = await client.listTasks();
tasks.forEach(task => {
  console.log(`${task.taskName}: ${task.status}`);
});
```
- Defined in src/lib/core/SingleAgentClient.ts:1622

getTaskInfo

getTaskInfo(taskId: string): Promise<null | TaskInfo>
Get detailed information about a specific task
Parameters
- taskId: string
  ID of the task to get information for
Returns Promise<null | TaskInfo>
Promise resolving to task information
- Defined in src/lib/core/SingleAgentClient.ts:1632

onTaskUpdate

onTaskUpdate(callback: (task: TaskInfo) => void): () => void
Subscribe to task notifications for this agent
Parameters
- callback: (task: TaskInfo) => void
  Function to call when task status changes
Returns () => void
Unsubscribe function
Example
```
const unsubscribe = client.onTaskUpdate((task) => {
  console.log(`Task ${task.taskName} is now ${task.status}`);
  if (task.status === 'completed') {
    // Handle completion
  }
});

// Later, stop listening
unsubscribe();
```
- Defined in src/lib/core/SingleAgentClient.ts:1655

onTaskEvents

onTaskEvents(
    callbacks: {
        onTaskCreated?: (task: TaskInfo) => void;
        onTaskUpdated?: (task: TaskInfo) => void;
        onTaskCompleted?: (task: TaskInfo) => void;
        onTaskFailed?: (task: TaskInfo, error: string) => void;
    },
): () => void
Subscribe to all task events (create, update, complete, error)
Parameters
- callbacks: {
      onTaskCreated?: (task: TaskInfo) => void;
      onTaskUpdated?: (task: TaskInfo) => void;
      onTaskCompleted?: (task: TaskInfo) => void;
      onTaskFailed?: (task: TaskInfo, error: string) => void;
  }
  Event callbacks for different task events
Returns () => void
Unsubscribe function
- Defined in src/lib/core/SingleAgentClient.ts:1665

registerWebhook

registerWebhook(webhookUrl: string, taskTypes?: string[]): Promise<void>
Register webhook URL for receiving task notifications
Parameters
- webhookUrl: string
  URL to receive webhook notifications
- OptionaltaskTypes: string[]
  Optional array of task types to watch (defaults to all)
Returns Promise<void>
Example
```
await client.registerWebhook('https://myapp.com/webhook', ['create_media_buy']);
```
- Defined in src/lib/core/SingleAgentClient.ts:1685

unregisterWebhook

unregisterWebhook(): Promise<void>
Unregister webhook notifications

Returns Promise<void>
- Defined in src/lib/core/SingleAgentClient.ts:1693

getAgentInfo

getAgentInfo(): Promise<
    {
        name: string;
        description?: string;
        protocol: "mcp"
        | "a2a";
        url: string;
        tools: {
            name: string;
            description?: string;
            inputSchema?: any;
            parameters?: string[];
        }[];
    },
>
Get comprehensive agent information including name, description, and available tools/skills

Works with both MCP (tools) and A2A (skills) protocols to discover what the agent can do.

Returns Promise<
    {
        name: string;
        description?: string;
        protocol: "mcp"
        | "a2a";
        url: string;
        tools: {
            name: string;
            description?: string;
            inputSchema?: any;
            parameters?: string[];
        }[];
    },
>
Promise resolving to agent information including tools
Example
```
const client = new ADCPClient(agentConfig);
const info = await client.getAgentInfo();

console.log(`${info.name}: ${info.description}`);
console.log(`Supports ${info.tools.length} tools`);

info.tools.forEach(tool => {
  console.log(`  - ${tool.name}: ${tool.description}`);
});
```
- Defined in src/lib/core/SingleAgentClient.ts:1720

getCapabilities

getCapabilities(): Promise<AdcpCapabilities>
Get agent capabilities, including AdCP version support

For v3 servers, calls get_adcp_capabilities tool. For v2 servers, builds synthetic capabilities from available tools.

Returns Promise<AdcpCapabilities>
Promise resolving to normalized capabilities object
Example
```
const capabilities = await client.getCapabilities();

console.log(`Server version: ${capabilities.version}`);
console.log(`Protocols: ${capabilities.protocols.join(', ')}`);

if (capabilities.features.propertyListFiltering) {
  // Use v3 property list features
}
```
- Defined in src/lib/core/SingleAgentClient.ts:1871

detectServerVersion

detectServerVersion(): Promise<"v2" | "v3">
Detect server AdCP version

Returns Promise<"v2" | "v3">
'v2' or 'v3' based on server capabilities
- Defined in src/lib/core/SingleAgentClient.ts:1912

supportsVersion

supportsVersion(version: 2 | 3): Promise<boolean>
Check if server supports a specific AdCP major version
Parameters
- version: 2 | 3
Returns Promise<boolean>
- Defined in src/lib/core/SingleAgentClient.ts:1920

`Static`discoverCreativeFormats

discoverCreativeFormats(
creativeAgentUrl: string,
protocol?: "mcp" | "a2a",
): Promise<Format[]>
Query a creative agent to discover available creative formats

This is a static utility method that allows you to query any creative agent (like creative.adcontextprotocol.org) to discover what formats are available before creating a media buy.
Parameters
- creativeAgentUrl: string
  URL of the creative agent (e.g., 'https://creative.adcontextprotocol.org/mcp')
- protocol: "mcp" | "a2a" = 'mcp'
  Protocol to use ('mcp' or 'a2a'), defaults to 'mcp'
Returns Promise<Format[]>
Promise resolving to the list of available formats
Example
```
// Discover formats from the standard creative agent
const formats = await SingleAgentClient.discoverCreativeFormats(
  'https://creative.adcontextprotocol.org/mcp'
);

// Find a specific format
const banner = formats.find(f => f.format_id.id === 'display_300x250_image');

// Use the format in a media buy
await salesAgent.createMediaBuy({
  packages: [{
    format_ids: [{
      agent_url: banner.format_id.agent_url,
      id: banner.format_id.id
    }]
  }]
});
```
- Defined in src/lib/core/SingleAgentClient.ts:1959

Class SingleAgentClient

Index

Constructors

Methods

Constructors

constructor

Parameters

Returns SingleAgentClient

Methods

handleWebhook

Parameters

Returns Promise<boolean>

Example

getWebhookUrl

Parameters

Returns string

Example

createWebhookHandler

Returns (req: any, res: any) => Promise<void>

Example: Express

Example: Next.js API Route

verifyWebhookSignature

Parameters

Returns boolean

getProducts

Parameters

Returns Promise<TaskResult<GetProductsResponse>>

Example

listCreativeFormats

Parameters

Returns Promise<TaskResult<ListCreativeFormatsResponse>>

createMediaBuy

Parameters

Returns Promise<TaskResult<CreateMediaBuyResponse>>

updateMediaBuy

Parameters

Returns Promise<TaskResult<UpdateMediaBuyResponse>>

syncCreatives

Parameters

Returns Promise<TaskResult<SyncCreativesResponse>>

listCreatives

Parameters

Returns Promise<TaskResult<ListCreativesResponse>>

previewCreative

Parameters

Returns Promise<TaskResult<PreviewCreativeResponse>>

getMediaBuyDelivery

Parameters

Returns Promise<TaskResult<GetMediaBuyDeliveryResponse>>

providePerformanceFeedback

Parameters

Returns Promise<TaskResult<ProvidePerformanceFeedbackResponse>>

getSignals

Parameters

Returns Promise<TaskResult<GetSignalsResponse>>

activateSignal

Parameters

Returns Promise<TaskResult<ActivateSignalResponse>>

getAdcpCapabilities

Parameters

Returns Promise<TaskResult<GetAdCPCapabilitiesResponse>>

executeTask

Type Parameters

Parameters

Returns Promise<TaskResult<T>>

Example

resumeDeferredTask

Type Parameters

Parameters

Returns Promise<TaskResult<T>>

Example

continueConversation

Type Parameters

Parameters

Returns Promise<TaskResult<T>>

Example

getConversationHistory

Parameters

Returns undefined | Message[]

clearConversationHistory

Returns Promise<
{
name: string;
description?: string;
protocol: "mcp"
| "a2a";
url: string;
tools: {
name: string;
description?: string;
inputSchema?: any;
parameters?: string[];
}[];
},
>

`Static`discoverCreativeFormats