r'''
# Xpander SDK

**Xpander Open Source SDK** empowers developers to build intelligent and reliable AI Agents capable of managing complex, multi-step tasks across diverse systems and platforms. The SDK simplifies challenges like function calling, schema definition, graph enforcement, and prompt group management.

With support for leading LLM providers such as OpenAI, Amazon Bedrock, and NVIDIA NIM, the **Xpander SDK** seamlessly integrates into your existing systems.

![ai-agents-with-xpander](static/images/screenshots/2024-11-19-21-45-27.png)

## 📦 Installation

Choose your preferred package manager:

### npm

```bash
npm install xpander-sdk
```

### pip

```bash
pip install xpander-sdk
```

## 🚀 Getting Started

### Prerequisites

1. Visit [app.xpander.ai](https://app.xpander.ai)
2. Retrieve your Agent Key from the Agent Settings page
3. Install the SDK and make sure you have Node.js installed (required as the SDK runs as a Node.js app under the hood)

### Quick Start Examples

<details><summary>TypeScript</summary>

```python
import { XpanderClient } from 'xpander-sdk';
import * as dotenv from 'dotenv';

dotenv.config();

const xpanderAPIKey = process.env.XPANDER_API_KEY || '';
const xpanderAgentID = process.env.XPANDER_AGENT_ID || '';

const xpanderClient = new XpanderClient({ apiKey: xpanderAPIKey });
const agent = await xpanderClient.agents.get(xpanderAgentID);

// Get available tools for the agent
const tools = await agent.getTools();

// This is a placeholder for AI to analyze the tools and decide which to invoke
// You would typically send these tools to your AI provider (e.g., OpenAI, Anthropic)
// The AI will return a structured response indicating which tools to call
const llmResponse = await yourAIProvider.chat.completions.create({
  messages: [userMessage],
  tools: tools // The tools are formatted for the AI to understand
  // ... other AI configuration
});

// Parse LLM response automatically into tool calls
const toolsToRun = XpanderClient.extractToolCalls(llmResponse);

// Execute multiple tool calls at once
const results = await agent.runTools(toolsToRun);
```

</details><details>
<summary>JavaScript</summary>

```javascript
const { XpanderClient } = require('xpander-sdk');
require('dotenv').config();

const xpanderAPIKey = process.env.XPANDER_API_KEY || '';
const xpanderAgentID = process.env.XPANDER_AGENT_ID || '';

const xpanderClient = new XpanderClient({ apiKey: xpanderAPIKey });
const agent = await xpanderClient.agents.get(xpanderAgentID);

// Get available tools for the agent
const tools = await agent.getTools();

// This is a placeholder for AI to analyze the tools and decide which to invoke
// You would typically send these tools to your AI provider (e.g., OpenAI, Anthropic)
// The AI will return a structured response indicating which tools to call
const llmResponse = await yourAIProvider.chat.completions.create({
  messages: [userMessage],
  tools: tools // The tools are formatted for the AI to understand
  // ... other AI configuration
});

// Parse LLM response automatically into tool calls
const toolsToRun = XpanderClient.extractToolCalls(llmResponse);

// Execute multiple tool calls at once
const results = await agent.runTools(toolsToRun);
```

</details><details>
<summary>Python</summary>

```python
from xpander_sdk import XpanderClient
from dotenv import load_dotenv
import os

load_dotenv()

xpanderAPIKey = os.environ.get("XPANDER_API_KEY", "")
xpanderAgentID = os.environ.get("XPANDER_AGENT_ID", "")

xpander_client = XpanderClient(api_key=xpanderAPIKey)
agent = xpander_client.agents.get(agent_id=xpanderAgentID)

# Get available tools for the agent
tools = agent.get_tools()

# This is a placeholder for AI to analyze the tools and decide which to invoke
# You would typically send these tools to your AI provider (e.g., OpenAI, Anthropic)
# The AI will return a structured response indicating which tools to call
llm_response = your_ai_provider.chat.completions.create(
    messages=[user_message],
    tools=tools  # The tools are formatted for the AI to understand
    # ... other AI configuration
)

# Parse LLM response automatically into tool calls
tools_to_run = XpanderClient.extract_tool_calls(llm_response=llm_response.model_dump())

# Execute multiple tool calls at once
results = agent.run_tools(tools_to_run)
```

</details><details>
<summary>C#</summary>

```csharp
using Xpander.Sdk;
using DotEnv.Net;

new DotEnvLoader().Load();

var xpanderAPIKey = Environment.GetEnvironmentVariable("XPANDER_API_KEY") ?? "";
var xpanderAgentID = Environment.GetEnvironmentVariable("XPANDER_AGENT_ID") ?? "";

var xpanderClient = new XpanderClient(xpanderAPIKey);
var agent = await xpanderClient.Agents.GetAsync(xpanderAgentID);

// Get available tools for the agent
var tools = await agent.GetToolsAsync();

// This is a placeholder for AI to analyze the tools and decide which to invoke
// You would typically send these tools to your AI provider (e.g., OpenAI, Anthropic)
// The AI will return a structured response indicating which tools to call
var llmResponse = await yourAIProvider.chat.completions.create({
  messages: [userMessage],
  tools: tools // The tools are formatted for the AI to understand
  // ... other AI configuration
});

// Parse LLM response automatically into tool calls
var toolsToRun = XpanderClient.ExtractToolCalls(llmResponse);

// Execute multiple tool calls at once
var results = await agent.RunToolsAsync(toolsToRun);
```

</details>

## 📚 Documentation

For comprehensive documentation, tutorials, and API references, visit:

* [Official Documentation](https://docs.xpander.ai/userguides/overview/introduction)
* [API Reference](https://docs.xpander.ai/api-reference/SDK/getting-started)

## ⚙️ Technical Note

The library is compiled using Projen and runs as a Node.js application under the hood. Ensure you have Node.js installed for optimal performance.

## 🤝 Contributing

We welcome contributions to improve the SDK. Please see our [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on how to submit improvements and bug fixes.
'''
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)

import abc
import builtins
import datetime
import enum
import typing

import jsii
import publication
import typing_extensions

import typeguard
from importlib.metadata import version as _metadata_package_version
TYPEGUARD_MAJOR_VERSION = int(_metadata_package_version('typeguard').split('.')[0])

def check_type(argname: str, value: object, expected_type: typing.Any) -> typing.Any:
    if TYPEGUARD_MAJOR_VERSION <= 2:
        return typeguard.check_type(argname=argname, value=value, expected_type=expected_type) # type:ignore
    else:
        if isinstance(value, jsii._reference_map.InterfaceDynamicProxy): # pyright: ignore [reportAttributeAccessIssue]
           pass
        else:
            if TYPEGUARD_MAJOR_VERSION == 3:
                typeguard.config.collection_check_strategy = typeguard.CollectionCheckStrategy.ALL_ITEMS # type:ignore
                typeguard.check_type(value=value, expected_type=expected_type) # type:ignore
            else:
                typeguard.check_type(value=value, expected_type=expected_type, collection_check_strategy=typeguard.CollectionCheckStrategy.ALL_ITEMS) # type:ignore

from ._jsii import *


@jsii.enum(jsii_type="xpander-sdk.AgentAccessScope")
class AgentAccessScope(enum.Enum):
    PERSONAL = "PERSONAL"
    ORGANIZATIONAL = "ORGANIZATIONAL"


@jsii.enum(jsii_type="xpander-sdk.AgentGraphItemSubType")
class AgentGraphItemSubType(enum.Enum):
    SDK = "SDK"
    TASK = "TASK"
    ASSISTANT = "ASSISTANT"
    WEBHOOK = "WEBHOOK"
    OPERATION = "OPERATION"
    CUSTOM_FUNCTION = "CUSTOM_FUNCTION"


@jsii.enum(jsii_type="xpander-sdk.AgentGraphItemType")
class AgentGraphItemType(enum.Enum):
    SOURCE_NODE = "SOURCE_NODE"
    AGENT = "AGENT"
    TOOL = "TOOL"
    HUMAN_IN_THE_LOOP = "HUMAN_IN_THE_LOOP"


@jsii.enum(jsii_type="xpander-sdk.AgentStatus")
class AgentStatus(enum.Enum):
    '''Enum representing the possible statuses of an agent.'''

    DRAFT = "DRAFT"
    ACTIVE = "ACTIVE"
    INACTIVE = "INACTIVE"


class Agents(metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.Agents"):
    '''Manages a collection of Agent instances in xpanderAI, providing methods to list, retrieve, and initialize agents, including custom agents.'''

    def __init__(self, configuration: "Configuration") -> None:
        '''Constructs an instance of the Agents manager.

        :param configuration: - Configuration settings for managing agents.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__56c927c42c835c774c6f5f1f6f97fed3b3214baccc5c46df58f7f5cf97262992)
            check_type(argname="argument configuration", value=configuration, expected_type=type_hints["configuration"])
        jsii.create(self.__class__, self, [configuration])

    @jsii.member(jsii_name="get")
    def get(self, agent_id: builtins.str) -> "Agent":
        '''Retrieves a specific agent by its ID and initializes it.

        :param agent_id: - The unique identifier of the agent to retrieve.

        :return: The requested Agent instance.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb382a0499d6ff9252ba35bb8f4c90a05697129cfe9cad98a7f8a1a14da8e1d4)
            check_type(argname="argument agent_id", value=agent_id, expected_type=type_hints["agent_id"])
        return typing.cast("Agent", jsii.invoke(self, "get", [agent_id]))

    @jsii.member(jsii_name="list")
    def list(self) -> typing.List["Agent"]:
        '''Retrieves the list of agents from the API and populates the local agents list.

        :return: An array of Agent instances.
        '''
        return typing.cast(typing.List["Agent"], jsii.invoke(self, "list", []))

    @builtins.property
    @jsii.member(jsii_name="agentsList")
    def agents_list(self) -> typing.List["Agent"]:
        '''Collection of Agent instances managed by this class.'''
        return typing.cast(typing.List["Agent"], jsii.get(self, "agentsList"))

    @agents_list.setter
    def agents_list(self, value: typing.List["Agent"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2f37932ab42616ef0215f3190c6c4bfa79237ec478d6c77803ea5cc9260af1f3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "agentsList", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="configuration")
    def configuration(self) -> "Configuration":
        '''- Configuration settings for managing agents.'''
        return typing.cast("Configuration", jsii.get(self, "configuration"))

    @configuration.setter
    def configuration(self, value: "Configuration") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec4b41eaf57993f4b49ed6bc9995e9ed9fa2685fb355f0d948717f7ea7e34c2f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "configuration", value) # pyright: ignore[reportArgumentType]


class AmazonBedrockSupportedModels(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="xpander-sdk.AmazonBedrockSupportedModels",
):
    '''Contains constants representing various models supported by Amazon Bedrock.'''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="ANTHROPIC_CLAUDE_3_5_SONNET_20240620")
    def ANTHROPIC_CLAUDE_3_5_SONNET_20240620(cls) -> builtins.str:
        '''Anthropocene Claude 3.5 Sonnet model (version 2024-06-20).'''
        return typing.cast(builtins.str, jsii.sget(cls, "ANTHROPIC_CLAUDE_3_5_SONNET_20240620"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="ANTHROPIC_CLAUDE_3_HAIKU_20240307")
    def ANTHROPIC_CLAUDE_3_HAIKU_20240307(cls) -> builtins.str:
        '''Anthropocene Claude 3 Haiku model (version 2024-03-07).'''
        return typing.cast(builtins.str, jsii.sget(cls, "ANTHROPIC_CLAUDE_3_HAIKU_20240307"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="COHERE_COMMAND_R")
    def COHERE_COMMAND_R(cls) -> builtins.str:
        '''Cohere Command R model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "COHERE_COMMAND_R"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="COHERE_COMMAND_R_PLUS")
    def COHERE_COMMAND_R_PLUS(cls) -> builtins.str:
        '''Cohere Command R Plus model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "COHERE_COMMAND_R_PLUS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="META_LLAMA3_1_405B_INSTRUCT")
    def META_LLAMA3_1_405_B_INSTRUCT(cls) -> builtins.str:
        '''Meta Llama 3 1.405B Instruct model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "META_LLAMA3_1_405B_INSTRUCT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="META_LLAMA3_1_70B_INSTRUCT")
    def META_LLAMA3_1_70_B_INSTRUCT(cls) -> builtins.str:
        '''Meta Llama 3 1.70B Instruct model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "META_LLAMA3_1_70B_INSTRUCT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="META_LLAMA3_1_8B_INSTRUCT")
    def META_LLAMA3_1_8_B_INSTRUCT(cls) -> builtins.str:
        '''Meta Llama 3 1.8B Instruct model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "META_LLAMA3_1_8B_INSTRUCT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MISTRAL_MISTRAL_LARGE_2402")
    def MISTRAL_MISTRAL_LARGE_2402(cls) -> builtins.str:
        '''Mistral Large 2402 model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "MISTRAL_MISTRAL_LARGE_2402"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MISTRAL_MISTRAL_LARGE_2407")
    def MISTRAL_MISTRAL_LARGE_2407(cls) -> builtins.str:
        '''Mistral Large 2407 model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "MISTRAL_MISTRAL_LARGE_2407"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MISTRAL_MISTRAL_SMALL_2402")
    def MISTRAL_MISTRAL_SMALL_2402(cls) -> builtins.str:
        '''Mistral Small 2402 model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "MISTRAL_MISTRAL_SMALL_2402"))


class _AmazonBedrockSupportedModelsProxy(AmazonBedrockSupportedModels):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, AmazonBedrockSupportedModels).__jsii_proxy_class__ = lambda : _AmazonBedrockSupportedModelsProxy


class Base(metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.Base"):
    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="fromObject")
    @builtins.classmethod
    def from_object(cls, data: typing.Any) -> "Base":
        '''
        :param data: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0dab3da5f8c0475ccab1873969e148ad9dcbdb0ddf88c9ecc6b02b751238b6e5)
            check_type(argname="argument data", value=data, expected_type=type_hints["data"])
        return typing.cast("Base", jsii.sinvoke(cls, "fromObject", [data]))

    @jsii.member(jsii_name="from")
    def from_(self, data: typing.Mapping[typing.Any, typing.Any]) -> "Base":
        '''
        :param data: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9d4d603584cc9880629c407e84565dc862d0614d798748f7556e51d6023943cb)
            check_type(argname="argument data", value=data, expected_type=type_hints["data"])
        return typing.cast("Base", jsii.invoke(self, "from", [data]))

    @jsii.member(jsii_name="toDict")
    def to_dict(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "toDict", []))

    @jsii.member(jsii_name="toJson")
    def to_json(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.invoke(self, "toJson", []))


class Configuration(
    Base,
    metaclass=jsii.JSIIMeta,
    jsii_type="xpander-sdk.Configuration",
):
    '''Manages the configuration settings for the xpanderAI client.

    This class encapsulates settings such as the API key, base URL,
    metrics reporting, and optional organization-specific parameters.
    '''

    def __init__(self, __0: "IConfiguration") -> None:
        '''Constructs a new Configuration instance.

        :param __0: - The API key for xpanderAI.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dafae5b4445df1b4c673783f144d770b151e831e63bc8be999b4708f966d5caa)
            check_type(argname="argument __0", value=__0, expected_type=type_hints["__0"])
        jsii.create(self.__class__, self, [__0])

    @builtins.property
    @jsii.member(jsii_name="url")
    def url(self) -> builtins.str:
        '''Constructs the full API endpoint URL.

        The URL combines the base URL with the optional organization ID if provided.

        :return: The constructed API endpoint URL.
        '''
        return typing.cast(builtins.str, jsii.get(self, "url"))

    @builtins.property
    @jsii.member(jsii_name="apiKey")
    def api_key(self) -> builtins.str:
        '''API key for authenticating requests to xpanderAI.'''
        return typing.cast(builtins.str, jsii.get(self, "apiKey"))

    @api_key.setter
    def api_key(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__135b56998170832cdd7296e91cdddd9c57d7b17d36e505bee4468b800785e5a3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "apiKey", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="baseUrl")
    def base_url(self) -> builtins.str:
        '''Base URL for the xpanderAI API requests.'''
        return typing.cast(builtins.str, jsii.get(self, "baseUrl"))

    @base_url.setter
    def base_url(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c6025924c03e9981cc1b85f95320de6d369f9970a79f6ee17298111769cddfa5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "baseUrl", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="withMetricsReport")
    def with_metrics_report(self) -> builtins.bool:
        '''Flag to enable or disable metrics reporting.'''
        return typing.cast(builtins.bool, jsii.get(self, "withMetricsReport"))

    @with_metrics_report.setter
    def with_metrics_report(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e66c1cb417d578246e8364e66bde633c4843b6604b43b28c0a1768e3d971c32a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "withMetricsReport", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="organizationId")
    def organization_id(self) -> typing.Optional[builtins.str]:
        '''Optional organization ID for scoped API requests.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "organizationId"))

    @organization_id.setter
    def organization_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__20369269e83a8faf9b0e5c03d8b299c924f1479bf7cf5b8c1b3b9f8bb93c406f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "organizationId", value) # pyright: ignore[reportArgumentType]


class Execution(Base, metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.Execution"):
    '''Represents an execution of an agent in xpanderAI, including its input, status, memory, and other related details.'''

    def __init__(
        self,
        id: builtins.str,
        agent_id: builtins.str,
        organization_id: builtins.str,
        input: "IExecutionInput",
        status: "ExecutionStatus",
        last_executed_node_id: typing.Optional[builtins.str] = None,
        memory_thread_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Constructs a new Execution instance.

        :param id: - Unique identifier of the execution.
        :param agent_id: - Identifier of the agent performing the execution.
        :param organization_id: - Identifier of the organization associated with the execution.
        :param input: - Input provided for the execution.
        :param status: - Current status of the execution.
        :param last_executed_node_id: - Identifier of the last executed node.
        :param memory_thread_id: - Identifier of the memory thread associated with the execution.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eb3511e5562e6adcbc92f800855d3a0afb25a625d0c55d5485a4a1dce9c4d0f5)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument agent_id", value=agent_id, expected_type=type_hints["agent_id"])
            check_type(argname="argument organization_id", value=organization_id, expected_type=type_hints["organization_id"])
            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
            check_type(argname="argument status", value=status, expected_type=type_hints["status"])
            check_type(argname="argument last_executed_node_id", value=last_executed_node_id, expected_type=type_hints["last_executed_node_id"])
            check_type(argname="argument memory_thread_id", value=memory_thread_id, expected_type=type_hints["memory_thread_id"])
        jsii.create(self.__class__, self, [id, agent_id, organization_id, input, status, last_executed_node_id, memory_thread_id])

    @jsii.member(jsii_name="update")
    @builtins.classmethod
    def update(
        cls,
        agent: "Agent",
        execution_id: builtins.str,
        delta: typing.Mapping[builtins.str, typing.Any],
    ) -> typing.Any:
        '''Updates an execution with the specified delta changes.

        :param agent: - The agent associated with the execution.
        :param execution_id: - The ID of the execution to update.
        :param delta: - A record of changes to apply to the execution.

        :return: The updated execution object.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4cee0f42d8d8dd5f66e986850120e23b19cc68cac936f98a8dd25fb36353d17a)
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
            check_type(argname="argument execution_id", value=execution_id, expected_type=type_hints["execution_id"])
            check_type(argname="argument delta", value=delta, expected_type=type_hints["delta"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "update", [agent, execution_id, delta]))

    @builtins.property
    @jsii.member(jsii_name="inputMessage")
    def input_message(self) -> "IMemoryMessage":
        '''Retrieves the input message formatted as a memory message.

        Combines text and file references into a single message object.

        :return: An object representing the user's input message.
        '''
        return typing.cast("IMemoryMessage", jsii.get(self, "inputMessage"))

    @builtins.property
    @jsii.member(jsii_name="agentId")
    def agent_id(self) -> builtins.str:
        '''- Identifier of the agent performing the execution.'''
        return typing.cast(builtins.str, jsii.get(self, "agentId"))

    @agent_id.setter
    def agent_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b03ca08f9b2b069041973b39cf02c9a0068d90548e5ddee63b20fe94c7012609)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "agentId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''- Unique identifier of the execution.'''
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @id.setter
    def id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6d868b6b5ce250193ce443b9016b04756769b83eeba535e78241ec0ff3f83d51)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="input")
    def input(self) -> "IExecutionInput":
        '''- Input provided for the execution.'''
        return typing.cast("IExecutionInput", jsii.get(self, "input"))

    @input.setter
    def input(self, value: "IExecutionInput") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fdf2cbec0d7a7f57322611349ee6da80c76ffc15d17073f0a02db00de934ea18)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "input", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="lastExecutedNodeId")
    def last_executed_node_id(self) -> builtins.str:
        '''- Identifier of the last executed node.'''
        return typing.cast(builtins.str, jsii.get(self, "lastExecutedNodeId"))

    @last_executed_node_id.setter
    def last_executed_node_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__35f14ab38fd58bcb6df93f21afda177a617f7ba0d607127377b3613011486dd7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "lastExecutedNodeId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="memoryThreadId")
    def memory_thread_id(self) -> builtins.str:
        '''- Identifier of the memory thread associated with the execution.'''
        return typing.cast(builtins.str, jsii.get(self, "memoryThreadId"))

    @memory_thread_id.setter
    def memory_thread_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71b5fe859564b314681ecc8ec189116efd662d6e84e6ac8185c34215670ec574)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "memoryThreadId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="organizationId")
    def organization_id(self) -> builtins.str:
        '''- Identifier of the organization associated with the execution.'''
        return typing.cast(builtins.str, jsii.get(self, "organizationId"))

    @organization_id.setter
    def organization_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__85cdb7bc0e59f92fdd53d0635a8fca37266c786acca82dac2cbfc332ac269981)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "organizationId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="status")
    def status(self) -> "ExecutionStatus":
        '''- Current status of the execution.'''
        return typing.cast("ExecutionStatus", jsii.get(self, "status"))

    @status.setter
    def status(self, value: "ExecutionStatus") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c6ea35b2f322e75bd9b6c5f06edfbe93b6c622ef9bc2c373933a362ffe4af250)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "status", value) # pyright: ignore[reportArgumentType]


@jsii.enum(jsii_type="xpander-sdk.ExecutionStatus")
class ExecutionStatus(enum.Enum):
    PENDING = "PENDING"
    EXECUTING = "EXECUTING"
    PAUSED = "PAUSED"
    ERROR = "ERROR"
    COMPLETED = "COMPLETED"


class FriendliAISupportedModels(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="xpander-sdk.FriendliAISupportedModels",
):
    '''Contains constants representing various models supported by OpenAI.

    :remarks:

    This abstract class defines static constants for the supported models
    by xpanderAI's OpenAI real-time integrations.
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="META_LLAMA_3_1_70B_INSTRUCT")
    def META_LLAMA_3_1_70_B_INSTRUCT(cls) -> builtins.str:
        '''Meta LLaMA 3.1 70B Instruct model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "META_LLAMA_3_1_70B_INSTRUCT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="META_LLAMA_3_1_8B_INSTRUCT")
    def META_LLAMA_3_1_8_B_INSTRUCT(cls) -> builtins.str:
        '''Meta LLaMA 3.1 8B Instruct model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "META_LLAMA_3_1_8B_INSTRUCT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="MISTRAL_8X_7B_INSTRUCT")
    def MISTRAL_8_X_7_B_INSTRUCT(cls) -> builtins.str:
        '''Mistral 8x7B Instruct model (version 0.1).'''
        return typing.cast(builtins.str, jsii.sget(cls, "MISTRAL_8X_7B_INSTRUCT"))


class _FriendliAISupportedModelsProxy(FriendliAISupportedModels):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, FriendliAISupportedModels).__jsii_proxy_class__ = lambda : _FriendliAISupportedModelsProxy


@jsii.interface(jsii_type="xpander-sdk.IAgentGraphItem")
class IAgentGraphItem(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        ...

    @id.setter
    def id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="itemId")
    def item_id(self) -> builtins.str:
        ...

    @item_id.setter
    def item_id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(self) -> typing.List[builtins.str]:
        ...

    @targets.setter
    def targets(self, value: typing.List[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> AgentGraphItemType:
        ...

    @type.setter
    def type(self, value: AgentGraphItemType) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> typing.Optional[builtins.str]:
        ...

    @name.setter
    def name(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="settings")
    def settings(self) -> typing.Optional["IAgentGraphItemSettings"]:
        ...

    @settings.setter
    def settings(self, value: typing.Optional["IAgentGraphItemSettings"]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="subType")
    def sub_type(self) -> typing.Optional[AgentGraphItemSubType]:
        ...

    @sub_type.setter
    def sub_type(self, value: typing.Optional[AgentGraphItemSubType]) -> None:
        ...


class _IAgentGraphItemProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IAgentGraphItem"

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @id.setter
    def id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5dba14c76a9e1d83ffe55a1c733b3576433fc58b9415d90dd9ac7028a869099b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="itemId")
    def item_id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "itemId"))

    @item_id.setter
    def item_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d1310bff172f40782302ad59d15f277cb3c0918376af5cffdc3a5d030bd54da2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "itemId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="targets")
    def targets(self) -> typing.List[builtins.str]:
        return typing.cast(typing.List[builtins.str], jsii.get(self, "targets"))

    @targets.setter
    def targets(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__13bb03bb81a62ba75e0b9bcc5c88b4bd2b3bcf54337bbc16151c4259035cb477)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "targets", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> AgentGraphItemType:
        return typing.cast(AgentGraphItemType, jsii.get(self, "type"))

    @type.setter
    def type(self, value: AgentGraphItemType) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__534c594af7204b33827b73b3778e3d1536c5b4c3bf435df83ae64f63dab6e844)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "name"))

    @name.setter
    def name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3a36cd909dd9399db70aeffbb9c356d023a3a896dbe5390dc5efe7c6414207b1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="settings")
    def settings(self) -> typing.Optional["IAgentGraphItemSettings"]:
        return typing.cast(typing.Optional["IAgentGraphItemSettings"], jsii.get(self, "settings"))

    @settings.setter
    def settings(self, value: typing.Optional["IAgentGraphItemSettings"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5618f24c0659df546079898a6172773cf1b206836e9c323ea2d1a760d8c827b8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "settings", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="subType")
    def sub_type(self) -> typing.Optional[AgentGraphItemSubType]:
        return typing.cast(typing.Optional[AgentGraphItemSubType], jsii.get(self, "subType"))

    @sub_type.setter
    def sub_type(self, value: typing.Optional[AgentGraphItemSubType]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__829f2208e58d3894303cd0b8b783a5a9e8634edee1b3a0b57974d04ac67611cc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "subType", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAgentGraphItem).__jsii_proxy_class__ = lambda : _IAgentGraphItemProxy


@jsii.interface(jsii_type="xpander-sdk.IAgentGraphItemAdvancedFilteringOption")
class IAgentGraphItemAdvancedFilteringOption(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="returnables")
    def returnables(self) -> typing.Optional[typing.List[builtins.str]]:
        ...

    @returnables.setter
    def returnables(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="searchables")
    def searchables(self) -> typing.Optional[typing.List[builtins.str]]:
        ...

    @searchables.setter
    def searchables(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        ...


class _IAgentGraphItemAdvancedFilteringOptionProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IAgentGraphItemAdvancedFilteringOption"

    @builtins.property
    @jsii.member(jsii_name="returnables")
    def returnables(self) -> typing.Optional[typing.List[builtins.str]]:
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "returnables"))

    @returnables.setter
    def returnables(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c37442176fd38f417112ebe47d309cfbcd7730390b5e828c327831187383b0b9)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "returnables", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="searchables")
    def searchables(self) -> typing.Optional[typing.List[builtins.str]]:
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "searchables"))

    @searchables.setter
    def searchables(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2a22b984d43570db7290f1372800735e3ac718279f0b81723ed1d35d12bc3e7f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "searchables", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAgentGraphItemAdvancedFilteringOption).__jsii_proxy_class__ = lambda : _IAgentGraphItemAdvancedFilteringOptionProxy


@jsii.interface(jsii_type="xpander-sdk.IAgentGraphItemSchema")
class IAgentGraphItemSchema(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="input")
    def input(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        ...

    @input.setter
    def input(
        self,
        value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
    ) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="output")
    def output(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        ...

    @output.setter
    def output(
        self,
        value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
    ) -> None:
        ...


class _IAgentGraphItemSchemaProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IAgentGraphItemSchema"

    @builtins.property
    @jsii.member(jsii_name="input")
    def input(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "input"))

    @input.setter
    def input(
        self,
        value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d83a27065ff688296f54a2b4a7b7bd9e2cf50799491f1783c29eecaa4fb598e3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "input", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="output")
    def output(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "output"))

    @output.setter
    def output(
        self,
        value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__10c09b4778194db94a8d00c666b7a1871afdce4091cd3cac67e6f78ea507904a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "output", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAgentGraphItemSchema).__jsii_proxy_class__ = lambda : _IAgentGraphItemSchemaProxy


@jsii.interface(jsii_type="xpander-sdk.IAgentGraphItemSettings")
class IAgentGraphItemSettings(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="advancedFilteringOptions")
    def advanced_filtering_options(
        self,
    ) -> typing.Optional[typing.List[IAgentGraphItemAdvancedFilteringOption]]:
        ...

    @advanced_filtering_options.setter
    def advanced_filtering_options(
        self,
        value: typing.Optional[typing.List[IAgentGraphItemAdvancedFilteringOption]],
    ) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        ...

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="instructions")
    def instructions(self) -> typing.Optional[builtins.str]:
        ...

    @instructions.setter
    def instructions(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="schemas")
    def schemas(self) -> typing.Optional[IAgentGraphItemSchema]:
        ...

    @schemas.setter
    def schemas(self, value: typing.Optional[IAgentGraphItemSchema]) -> None:
        ...


class _IAgentGraphItemSettingsProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IAgentGraphItemSettings"

    @builtins.property
    @jsii.member(jsii_name="advancedFilteringOptions")
    def advanced_filtering_options(
        self,
    ) -> typing.Optional[typing.List[IAgentGraphItemAdvancedFilteringOption]]:
        return typing.cast(typing.Optional[typing.List[IAgentGraphItemAdvancedFilteringOption]], jsii.get(self, "advancedFilteringOptions"))

    @advanced_filtering_options.setter
    def advanced_filtering_options(
        self,
        value: typing.Optional[typing.List[IAgentGraphItemAdvancedFilteringOption]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82ddafee8c7509fd377d08cd4dcb4bd75f290d6cfee8836b9158c69a50a8d205)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "advancedFilteringOptions", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))

    @description.setter
    def description(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__48133c207df167a1e2ac7d22c1e6b7159bb3845cf34a55f28a9c340e4b17b5a0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="instructions")
    def instructions(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "instructions"))

    @instructions.setter
    def instructions(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f5abe35889371107b0a28dc1777a7eed9117daefb0245778d0a219398b8b30de)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instructions", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="schemas")
    def schemas(self) -> typing.Optional[IAgentGraphItemSchema]:
        return typing.cast(typing.Optional[IAgentGraphItemSchema], jsii.get(self, "schemas"))

    @schemas.setter
    def schemas(self, value: typing.Optional[IAgentGraphItemSchema]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__60c048394bfb4cd680c4e606cd9f9da38990e641593522bda31ffc5307812b9f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "schemas", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAgentGraphItemSettings).__jsii_proxy_class__ = lambda : _IAgentGraphItemSettingsProxy


@jsii.interface(jsii_type="xpander-sdk.IAgentInstructions")
class IAgentInstructions(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="general")
    def general(self) -> builtins.str:
        ...

    @general.setter
    def general(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="goal")
    def goal(self) -> builtins.str:
        ...

    @goal.setter
    def goal(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="role")
    def role(self) -> builtins.str:
        ...

    @role.setter
    def role(self, value: builtins.str) -> None:
        ...


class _IAgentInstructionsProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IAgentInstructions"

    @builtins.property
    @jsii.member(jsii_name="general")
    def general(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "general"))

    @general.setter
    def general(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0a6ff80d5352340efac054e4b2567cc15950865e97d6cb43effd5e46955a1509)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "general", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="goal")
    def goal(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "goal"))

    @goal.setter
    def goal(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__369b7570f3bb8d2e15f006de040b07d3b8bba3ff139b444614a52dad91982ca0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "goal", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="role")
    def role(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "role"))

    @role.setter
    def role(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0187dbb1b47ed4f762b69eaa81fd084a3a63cd5320cda1ccc47f169afaa2fdde)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "role", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAgentInstructions).__jsii_proxy_class__ = lambda : _IAgentInstructionsProxy


@jsii.interface(jsii_type="xpander-sdk.IAgentTool")
class IAgentTool(typing_extensions.Protocol):
    '''Interface representing a tool available to an agent.'''

    @builtins.property
    @jsii.member(jsii_name="functionDescription")
    def function_description(self) -> builtins.str:
        '''Function-level description for the tool.'''
        ...

    @function_description.setter
    def function_description(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''Unique identifier for the tool.'''
        ...

    @id.setter
    def id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="method")
    def method(self) -> builtins.str:
        '''HTTP method used to call the tool.'''
        ...

    @method.setter
    def method(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''Name of the tool.'''
        ...

    @name.setter
    def name(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(self) -> typing.Any:
        '''Parameters required for executing the tool.'''
        ...

    @parameters.setter
    def parameters(self, value: typing.Any) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="path")
    def path(self) -> builtins.str:
        '''Endpoint path for the tool.'''
        ...

    @path.setter
    def path(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="pathParams")
    def path_params(self) -> typing.Any:
        '''Parameters for path in the tool’s endpoint.'''
        ...

    @path_params.setter
    def path_params(self, value: typing.Any) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="queryParams")
    def query_params(self) -> typing.Any:
        '''Parameters for query in the tool’s endpoint.'''
        ...

    @query_params.setter
    def query_params(self, value: typing.Any) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="rawDescription")
    def raw_description(self) -> builtins.str:
        '''Raw description of the tool.'''
        ...

    @raw_description.setter
    def raw_description(self, value: builtins.str) -> None:
        ...


class _IAgentToolProxy:
    '''Interface representing a tool available to an agent.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IAgentTool"

    @builtins.property
    @jsii.member(jsii_name="functionDescription")
    def function_description(self) -> builtins.str:
        '''Function-level description for the tool.'''
        return typing.cast(builtins.str, jsii.get(self, "functionDescription"))

    @function_description.setter
    def function_description(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__013ed94cf5075f5bf0c5bc74a0e8036501c284d35e4392ea6f15080eddc2a7ad)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "functionDescription", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''Unique identifier for the tool.'''
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @id.setter
    def id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b1b25237ddc5e6038acd2ee375459e97263388f5a79c9b19df1509b8ad33817e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="method")
    def method(self) -> builtins.str:
        '''HTTP method used to call the tool.'''
        return typing.cast(builtins.str, jsii.get(self, "method"))

    @method.setter
    def method(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2ba86af1a111c4132196288035231114364f7fd5846ba31b895e28cf0263f6b0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "method", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''Name of the tool.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bdd4d28b7b8f38ee90640906c0dfa66779e13f1537479bfac62236199af53599)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(self) -> typing.Any:
        '''Parameters required for executing the tool.'''
        return typing.cast(typing.Any, jsii.get(self, "parameters"))

    @parameters.setter
    def parameters(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bfb31aa04b21eb4806b8482aa225a11b478a08f9a3d8fe6ed1ff02f818c62244)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "parameters", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="path")
    def path(self) -> builtins.str:
        '''Endpoint path for the tool.'''
        return typing.cast(builtins.str, jsii.get(self, "path"))

    @path.setter
    def path(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7629b10507753cd17f8a141e1f5acf42aa3ad6279b11466521e8e879158f1c0b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "path", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="pathParams")
    def path_params(self) -> typing.Any:
        '''Parameters for path in the tool’s endpoint.'''
        return typing.cast(typing.Any, jsii.get(self, "pathParams"))

    @path_params.setter
    def path_params(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0c1639f3cf0ce4876316784b66d4eb55d50082b87dcaa56347a0ebcb4c5be615)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "pathParams", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="queryParams")
    def query_params(self) -> typing.Any:
        '''Parameters for query in the tool’s endpoint.'''
        return typing.cast(typing.Any, jsii.get(self, "queryParams"))

    @query_params.setter
    def query_params(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76420473c4800542a5c924d1375223fda76771d1a194354c646c87a134351b2d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "queryParams", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="rawDescription")
    def raw_description(self) -> builtins.str:
        '''Raw description of the tool.'''
        return typing.cast(builtins.str, jsii.get(self, "rawDescription"))

    @raw_description.setter
    def raw_description(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__94d18303f76ca1cea7f0333afa6e171a5ff4c99c53601d4772e5d916b00ae6de)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "rawDescription", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAgentTool).__jsii_proxy_class__ = lambda : _IAgentToolProxy


@jsii.interface(jsii_type="xpander-sdk.IBedrockTool")
class IBedrockTool(typing_extensions.Protocol):
    '''Interface representing a Bedrock tool.'''

    @builtins.property
    @jsii.member(jsii_name="toolSpec")
    def tool_spec(self) -> "IBedrockToolSpec":
        '''Specification details for the Bedrock tool.'''
        ...

    @tool_spec.setter
    def tool_spec(self, value: "IBedrockToolSpec") -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="execute")
    def execute(self) -> typing.Any:
        '''Function to execute the tool, if defined.'''
        ...

    @execute.setter
    def execute(self, value: typing.Any) -> None:
        ...


class _IBedrockToolProxy:
    '''Interface representing a Bedrock tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IBedrockTool"

    @builtins.property
    @jsii.member(jsii_name="toolSpec")
    def tool_spec(self) -> "IBedrockToolSpec":
        '''Specification details for the Bedrock tool.'''
        return typing.cast("IBedrockToolSpec", jsii.get(self, "toolSpec"))

    @tool_spec.setter
    def tool_spec(self, value: "IBedrockToolSpec") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__686bee2f9cc4cb8e5e46bd20309c912c48752fa01feec49d211288fe414d9879)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "toolSpec", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="execute")
    def execute(self) -> typing.Any:
        '''Function to execute the tool, if defined.'''
        return typing.cast(typing.Any, jsii.get(self, "execute"))

    @execute.setter
    def execute(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__50442d45bad8e7fa927b6be3feac263e79712091c62056e831a391b5a17c13bc)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "execute", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IBedrockTool).__jsii_proxy_class__ = lambda : _IBedrockToolProxy


@jsii.interface(jsii_type="xpander-sdk.IBedrockToolOutput")
class IBedrockToolOutput(typing_extensions.Protocol):
    '''Output interface for a Bedrock tool.'''

    @builtins.property
    @jsii.member(jsii_name="toolSpec")
    def tool_spec(self) -> "IBedrockToolSpec":
        '''Specification of the Bedrock tool.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="execute")
    def execute(self) -> typing.Any:
        '''Function to execute the Bedrock tool.'''
        ...


class _IBedrockToolOutputProxy:
    '''Output interface for a Bedrock tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IBedrockToolOutput"

    @builtins.property
    @jsii.member(jsii_name="toolSpec")
    def tool_spec(self) -> "IBedrockToolSpec":
        '''Specification of the Bedrock tool.'''
        return typing.cast("IBedrockToolSpec", jsii.get(self, "toolSpec"))

    @builtins.property
    @jsii.member(jsii_name="execute")
    def execute(self) -> typing.Any:
        '''Function to execute the Bedrock tool.'''
        return typing.cast(typing.Any, jsii.get(self, "execute"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IBedrockToolOutput).__jsii_proxy_class__ = lambda : _IBedrockToolOutputProxy


@jsii.interface(jsii_type="xpander-sdk.IBedrockToolSpec")
class IBedrockToolSpec(typing_extensions.Protocol):
    '''Interface representing the specification for a Bedrock tool.'''

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''Description of what the Bedrock tool does.'''
        ...

    @description.setter
    def description(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="inputSchema")
    def input_schema(self) -> "IBedrockToolSpecInputSchema":
        '''Input schema detailing required parameters for the tool.'''
        ...

    @input_schema.setter
    def input_schema(self, value: "IBedrockToolSpecInputSchema") -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the Bedrock tool.'''
        ...

    @name.setter
    def name(self, value: builtins.str) -> None:
        ...


class _IBedrockToolSpecProxy:
    '''Interface representing the specification for a Bedrock tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IBedrockToolSpec"

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''Description of what the Bedrock tool does.'''
        return typing.cast(builtins.str, jsii.get(self, "description"))

    @description.setter
    def description(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bab15f7ad29e9cbdf37869d4d12b1eca4937a0130eb1409bb74f1149d0dfc26b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="inputSchema")
    def input_schema(self) -> "IBedrockToolSpecInputSchema":
        '''Input schema detailing required parameters for the tool.'''
        return typing.cast("IBedrockToolSpecInputSchema", jsii.get(self, "inputSchema"))

    @input_schema.setter
    def input_schema(self, value: "IBedrockToolSpecInputSchema") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__39dfbf6fa195f65cf55b428cbf9c7e700af738bcd9c47ebdda318cfedf78e70a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "inputSchema", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the Bedrock tool.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0534d2b1daae9caffc87b99f4b6cc09e1a9eac3888374c04e9c619375c2f1b35)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IBedrockToolSpec).__jsii_proxy_class__ = lambda : _IBedrockToolSpecProxy


@jsii.interface(jsii_type="xpander-sdk.IBedrockToolSpecInputSchema")
class IBedrockToolSpecInputSchema(typing_extensions.Protocol):
    '''Interface representing the input schema for a Bedrock tool.'''

    @builtins.property
    @jsii.member(jsii_name="json")
    def json(self) -> typing.Mapping[builtins.str, "IToolParameter"]:
        '''JSON schema defining the parameters for the tool.'''
        ...

    @json.setter
    def json(self, value: typing.Mapping[builtins.str, "IToolParameter"]) -> None:
        ...


class _IBedrockToolSpecInputSchemaProxy:
    '''Interface representing the input schema for a Bedrock tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IBedrockToolSpecInputSchema"

    @builtins.property
    @jsii.member(jsii_name="json")
    def json(self) -> typing.Mapping[builtins.str, "IToolParameter"]:
        '''JSON schema defining the parameters for the tool.'''
        return typing.cast(typing.Mapping[builtins.str, "IToolParameter"], jsii.get(self, "json"))

    @json.setter
    def json(self, value: typing.Mapping[builtins.str, "IToolParameter"]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1454322c6f1b39bdf36a5d88226526fce2d55d1e13ada58cf00d44f12fd64366)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "json", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IBedrockToolSpecInputSchema).__jsii_proxy_class__ = lambda : _IBedrockToolSpecInputSchemaProxy


@jsii.interface(jsii_type="xpander-sdk.IConfiguration")
class IConfiguration(typing_extensions.Protocol):
    '''Interface representing configuration settings for the xpanderAI client.'''

    @builtins.property
    @jsii.member(jsii_name="apiKey")
    def api_key(self) -> builtins.str:
        '''API key for authenticating with xpanderAI.'''
        ...

    @api_key.setter
    def api_key(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="baseUrl")
    def base_url(self) -> typing.Optional[builtins.str]:
        '''Optional base URL for the xpanderAI API.'''
        ...

    @base_url.setter
    def base_url(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="organizationId")
    def organization_id(self) -> typing.Optional[builtins.str]:
        '''Custom parameters for client-specific settings.'''
        ...

    @organization_id.setter
    def organization_id(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="withMetricsReport")
    def with_metrics_report(self) -> typing.Optional[builtins.bool]:
        '''Optional flag to enable metrics reporting.'''
        ...

    @with_metrics_report.setter
    def with_metrics_report(self, value: typing.Optional[builtins.bool]) -> None:
        ...


class _IConfigurationProxy:
    '''Interface representing configuration settings for the xpanderAI client.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IConfiguration"

    @builtins.property
    @jsii.member(jsii_name="apiKey")
    def api_key(self) -> builtins.str:
        '''API key for authenticating with xpanderAI.'''
        return typing.cast(builtins.str, jsii.get(self, "apiKey"))

    @api_key.setter
    def api_key(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3e8b15e3c3381cc6704c1ee29aa4c16d1b4a86e2ac011b6e441b3e0b431f930)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "apiKey", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="baseUrl")
    def base_url(self) -> typing.Optional[builtins.str]:
        '''Optional base URL for the xpanderAI API.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "baseUrl"))

    @base_url.setter
    def base_url(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__07a526e81165d7b0acee70572029a007577d042379f52fcd7844f14a292ff14e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "baseUrl", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="organizationId")
    def organization_id(self) -> typing.Optional[builtins.str]:
        '''Custom parameters for client-specific settings.'''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "organizationId"))

    @organization_id.setter
    def organization_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__df183128da8ce312ade8f62d98d9db3bba128d9acf1d9f56955baae69e409c37)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "organizationId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="withMetricsReport")
    def with_metrics_report(self) -> typing.Optional[builtins.bool]:
        '''Optional flag to enable metrics reporting.'''
        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "withMetricsReport"))

    @with_metrics_report.setter
    def with_metrics_report(self, value: typing.Optional[builtins.bool]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1540b2d417df65eae973c655ee643690a0dcd51cb4e6c7e9d779c317f9cec97a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "withMetricsReport", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IConfiguration).__jsii_proxy_class__ = lambda : _IConfigurationProxy


@jsii.interface(jsii_type="xpander-sdk.IExecutionInput")
class IExecutionInput(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="user")
    def user(self) -> "IUserDetails":
        ...

    @user.setter
    def user(self, value: "IUserDetails") -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="files")
    def files(self) -> typing.Optional[typing.List[builtins.str]]:
        ...

    @files.setter
    def files(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="text")
    def text(self) -> typing.Optional[builtins.str]:
        ...

    @text.setter
    def text(self, value: typing.Optional[builtins.str]) -> None:
        ...


class _IExecutionInputProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IExecutionInput"

    @builtins.property
    @jsii.member(jsii_name="user")
    def user(self) -> "IUserDetails":
        return typing.cast("IUserDetails", jsii.get(self, "user"))

    @user.setter
    def user(self, value: "IUserDetails") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__da3a818f4694a99ea585b769eb098754a7fe2d1868cc0704ace9d8e92ba7f3f1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "user", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="files")
    def files(self) -> typing.Optional[typing.List[builtins.str]]:
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "files"))

    @files.setter
    def files(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ded72ddaf5f71f91ade05bb19c950ea501c6e1e1233100d5f19c597947e7d3aa)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "files", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="text")
    def text(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "text"))

    @text.setter
    def text(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8eb39d06928f51e090591017e234f9560633786e66b238d3b42531c3252f0eea)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "text", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IExecutionInput).__jsii_proxy_class__ = lambda : _IExecutionInputProxy


@jsii.interface(jsii_type="xpander-sdk.IGraphItem")
class IGraphItem(typing_extensions.Protocol):
    '''Interface representing an item in an agent's graph, containing the structure of connected nodes, prompt details, and associated group information.'''

    @builtins.property
    @jsii.member(jsii_name="enrichedPrompts")
    def enriched_prompts(self) -> typing.List[builtins.str]:
        '''Array of enriched prompts, providing additional context or formatting.'''
        ...

    @enriched_prompts.setter
    def enriched_prompts(self, value: typing.List[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="graph")
    def graph(self) -> typing.Mapping[builtins.str, typing.List[builtins.str]]:
        '''Representation of the graph structure with nodes and their connections.'''
        ...

    @graph.setter
    def graph(
        self,
        value: typing.Mapping[builtins.str, typing.List[builtins.str]],
    ) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="promptGroupId")
    def prompt_group_id(self) -> builtins.str:
        '''Unique identifier for the prompt group associated with this graph item.'''
        ...

    @prompt_group_id.setter
    def prompt_group_id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="prompts")
    def prompts(self) -> typing.List[builtins.str]:
        '''Array of prompt texts associated with the graph item.'''
        ...

    @prompts.setter
    def prompts(self, value: typing.List[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="startingNode")
    def starting_node(self) -> builtins.str:
        '''Identifier for the starting node in the graph.'''
        ...

    @starting_node.setter
    def starting_node(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="operationNodesInstructions")
    def operation_nodes_instructions(
        self,
    ) -> typing.Optional[typing.List["IOperationNodeInstructions"]]:
        ...

    @operation_nodes_instructions.setter
    def operation_nodes_instructions(
        self,
        value: typing.Optional[typing.List["IOperationNodeInstructions"]],
    ) -> None:
        ...


class _IGraphItemProxy:
    '''Interface representing an item in an agent's graph, containing the structure of connected nodes, prompt details, and associated group information.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IGraphItem"

    @builtins.property
    @jsii.member(jsii_name="enrichedPrompts")
    def enriched_prompts(self) -> typing.List[builtins.str]:
        '''Array of enriched prompts, providing additional context or formatting.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "enrichedPrompts"))

    @enriched_prompts.setter
    def enriched_prompts(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__63dac3f67c0f52d800dcd097be9ddb6eb98f70c71ea8289dbaad0e94a58d47f1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "enrichedPrompts", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="graph")
    def graph(self) -> typing.Mapping[builtins.str, typing.List[builtins.str]]:
        '''Representation of the graph structure with nodes and their connections.'''
        return typing.cast(typing.Mapping[builtins.str, typing.List[builtins.str]], jsii.get(self, "graph"))

    @graph.setter
    def graph(
        self,
        value: typing.Mapping[builtins.str, typing.List[builtins.str]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__53cbdb3cb6871f560d5a0a78bd2ceff7528297ba8da6e71aa3da216d1c0284f2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "graph", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="promptGroupId")
    def prompt_group_id(self) -> builtins.str:
        '''Unique identifier for the prompt group associated with this graph item.'''
        return typing.cast(builtins.str, jsii.get(self, "promptGroupId"))

    @prompt_group_id.setter
    def prompt_group_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eaa5a9bfea7b1902145aadecc5674d2699888d69e501b26b8c8c3ad694675881)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "promptGroupId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="prompts")
    def prompts(self) -> typing.List[builtins.str]:
        '''Array of prompt texts associated with the graph item.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "prompts"))

    @prompts.setter
    def prompts(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__42a9c3fc5cff09316502fc55db2175287af1ef6831a515963059bd6de019711a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "prompts", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="startingNode")
    def starting_node(self) -> builtins.str:
        '''Identifier for the starting node in the graph.'''
        return typing.cast(builtins.str, jsii.get(self, "startingNode"))

    @starting_node.setter
    def starting_node(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__57c77329d9ea483c6111ccb444f6e30c3a08d7baf27c81a55cc015bb38ed9369)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "startingNode", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="operationNodesInstructions")
    def operation_nodes_instructions(
        self,
    ) -> typing.Optional[typing.List["IOperationNodeInstructions"]]:
        return typing.cast(typing.Optional[typing.List["IOperationNodeInstructions"]], jsii.get(self, "operationNodesInstructions"))

    @operation_nodes_instructions.setter
    def operation_nodes_instructions(
        self,
        value: typing.Optional[typing.List["IOperationNodeInstructions"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6269099b38fe2e344fbcf8d67e4d22c04f53523963a6b49a82311bfff413a54b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "operationNodesInstructions", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IGraphItem).__jsii_proxy_class__ = lambda : _IGraphItemProxy


@jsii.interface(jsii_type="xpander-sdk.ILocalTool")
class ILocalTool(typing_extensions.Protocol):
    '''Interface for a local tool.'''

    @builtins.property
    @jsii.member(jsii_name="function")
    def function(self) -> "ILocalToolFunction":
        '''Function specification for the local tool.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''Specifies the tool type as a 'function'.'''
        ...


class _ILocalToolProxy:
    '''Interface for a local tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.ILocalTool"

    @builtins.property
    @jsii.member(jsii_name="function")
    def function(self) -> "ILocalToolFunction":
        '''Function specification for the local tool.'''
        return typing.cast("ILocalToolFunction", jsii.get(self, "function"))

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''Specifies the tool type as a 'function'.'''
        return typing.cast(builtins.str, jsii.get(self, "type"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ILocalTool).__jsii_proxy_class__ = lambda : _ILocalToolProxy


@jsii.interface(jsii_type="xpander-sdk.ILocalToolFunction")
class ILocalToolFunction(typing_extensions.Protocol):
    '''Interface for a function within a local tool.'''

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''Description of the local tool's purpose.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the local tool function.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(self) -> typing.Any:
        '''Parameters used by the local tool function.'''
        ...


class _ILocalToolFunctionProxy:
    '''Interface for a function within a local tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.ILocalToolFunction"

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''Description of the local tool's purpose.'''
        return typing.cast(builtins.str, jsii.get(self, "description"))

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the local tool function.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(self) -> typing.Any:
        '''Parameters used by the local tool function.'''
        return typing.cast(typing.Any, jsii.get(self, "parameters"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ILocalToolFunction).__jsii_proxy_class__ = lambda : _ILocalToolFunctionProxy


@jsii.interface(jsii_type="xpander-sdk.IMemoryMessage")
class IMemoryMessage(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="role")
    def role(self) -> builtins.str:
        ...

    @role.setter
    def role(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="content")
    def content(self) -> typing.Optional[builtins.str]:
        ...

    @content.setter
    def content(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="nodeName")
    def node_name(self) -> typing.Optional[builtins.str]:
        ...

    @node_name.setter
    def node_name(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="toolCallId")
    def tool_call_id(self) -> typing.Optional[builtins.str]:
        ...

    @tool_call_id.setter
    def tool_call_id(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="toolCalls")
    def tool_calls(self) -> typing.Optional[typing.List["IToolCall"]]:
        ...

    @tool_calls.setter
    def tool_calls(self, value: typing.Optional[typing.List["IToolCall"]]) -> None:
        ...


class _IMemoryMessageProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IMemoryMessage"

    @builtins.property
    @jsii.member(jsii_name="role")
    def role(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "role"))

    @role.setter
    def role(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12e375f6294f1a5448700c974b2c29d93eaac36a1dea798ca8ded9b92594d10b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "role", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="content")
    def content(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "content"))

    @content.setter
    def content(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e2af096115236a1c0df0e3b558acc615c594ec3a2f016074ae50c4c83fcb2600)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "content", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="nodeName")
    def node_name(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "nodeName"))

    @node_name.setter
    def node_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__221c82f5a357c0f118efe86c29a8a97b2a8f51d955265c9972dc156543547bb0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "nodeName", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="toolCallId")
    def tool_call_id(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "toolCallId"))

    @tool_call_id.setter
    def tool_call_id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d263d1c0fb18bd7e903fe0d0af692e3808ac21c99197a495a3f6c62acba8a50b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "toolCallId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="toolCalls")
    def tool_calls(self) -> typing.Optional[typing.List["IToolCall"]]:
        return typing.cast(typing.Optional[typing.List["IToolCall"]], jsii.get(self, "toolCalls"))

    @tool_calls.setter
    def tool_calls(self, value: typing.Optional[typing.List["IToolCall"]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__25eaf42500bdb62a0efcb583df3587ae560b4f99f9d9214b8ebebc6131aec02e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "toolCalls", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IMemoryMessage).__jsii_proxy_class__ = lambda : _IMemoryMessageProxy


@jsii.interface(jsii_type="xpander-sdk.INodeDescription")
class INodeDescription(typing_extensions.Protocol):
    '''Represents a prompt group + node name node's description override.'''

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        ...

    @builtins.property
    @jsii.member(jsii_name="nodeName")
    def node_name(self) -> builtins.str:
        ...

    @builtins.property
    @jsii.member(jsii_name="promptGroupId")
    def prompt_group_id(self) -> builtins.str:
        ...


class _INodeDescriptionProxy:
    '''Represents a prompt group + node name node's description override.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.INodeDescription"

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "description"))

    @builtins.property
    @jsii.member(jsii_name="nodeName")
    def node_name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "nodeName"))

    @builtins.property
    @jsii.member(jsii_name="promptGroupId")
    def prompt_group_id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "promptGroupId"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, INodeDescription).__jsii_proxy_class__ = lambda : _INodeDescriptionProxy


@jsii.interface(jsii_type="xpander-sdk.INodeSchema")
class INodeSchema(typing_extensions.Protocol):
    '''Represents the schema of a single node with defined input and output structures.'''

    @builtins.property
    @jsii.member(jsii_name="input")
    def input(self) -> typing.Any:
        ...

    @builtins.property
    @jsii.member(jsii_name="nodeName")
    def node_name(self) -> builtins.str:
        ...

    @builtins.property
    @jsii.member(jsii_name="output")
    def output(self) -> typing.Any:
        ...


class _INodeSchemaProxy:
    '''Represents the schema of a single node with defined input and output structures.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.INodeSchema"

    @builtins.property
    @jsii.member(jsii_name="input")
    def input(self) -> typing.Any:
        return typing.cast(typing.Any, jsii.get(self, "input"))

    @builtins.property
    @jsii.member(jsii_name="nodeName")
    def node_name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "nodeName"))

    @builtins.property
    @jsii.member(jsii_name="output")
    def output(self) -> typing.Any:
        return typing.cast(typing.Any, jsii.get(self, "output"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, INodeSchema).__jsii_proxy_class__ = lambda : _INodeSchemaProxy


@jsii.interface(jsii_type="xpander-sdk.IOpenAIToolFunctionOutput")
class IOpenAIToolFunctionOutput(typing_extensions.Protocol):
    '''Output interface for an OpenAI tool function.'''

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''Description of the tool function's purpose.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the tool function.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="execute")
    def execute(self) -> typing.Any:
        '''Secondary execution function for Bedrock compatibility.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="func")
    def func(self) -> typing.Any:
        '''Primary function to execute the tool.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(self) -> typing.Optional["IToolParameter"]:
        '''Parameters required for the tool function.'''
        ...


class _IOpenAIToolFunctionOutputProxy:
    '''Output interface for an OpenAI tool function.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IOpenAIToolFunctionOutput"

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''Description of the tool function's purpose.'''
        return typing.cast(builtins.str, jsii.get(self, "description"))

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the tool function.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @builtins.property
    @jsii.member(jsii_name="execute")
    def execute(self) -> typing.Any:
        '''Secondary execution function for Bedrock compatibility.'''
        return typing.cast(typing.Any, jsii.get(self, "execute"))

    @builtins.property
    @jsii.member(jsii_name="func")
    def func(self) -> typing.Any:
        '''Primary function to execute the tool.'''
        return typing.cast(typing.Any, jsii.get(self, "func"))

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(self) -> typing.Optional["IToolParameter"]:
        '''Parameters required for the tool function.'''
        return typing.cast(typing.Optional["IToolParameter"], jsii.get(self, "parameters"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IOpenAIToolFunctionOutput).__jsii_proxy_class__ = lambda : _IOpenAIToolFunctionOutputProxy


@jsii.interface(jsii_type="xpander-sdk.IOpenAIToolOutput")
class IOpenAIToolOutput(typing_extensions.Protocol):
    '''Output interface for an OpenAI tool.'''

    @builtins.property
    @jsii.member(jsii_name="function")
    def function(self) -> IOpenAIToolFunctionOutput:
        '''Function specification for the OpenAI tool.'''
        ...

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''Type of the tool, typically 'function'.'''
        ...


class _IOpenAIToolOutputProxy:
    '''Output interface for an OpenAI tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IOpenAIToolOutput"

    @builtins.property
    @jsii.member(jsii_name="function")
    def function(self) -> IOpenAIToolFunctionOutput:
        '''Function specification for the OpenAI tool.'''
        return typing.cast(IOpenAIToolFunctionOutput, jsii.get(self, "function"))

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''Type of the tool, typically 'function'.'''
        return typing.cast(builtins.str, jsii.get(self, "type"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IOpenAIToolOutput).__jsii_proxy_class__ = lambda : _IOpenAIToolOutputProxy


@jsii.interface(jsii_type="xpander-sdk.IOperationNodeInstructions")
class IOperationNodeInstructions(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="instructions")
    def instructions(self) -> builtins.str:
        ...

    @instructions.setter
    def instructions(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="nodeIndexInGraph")
    def node_index_in_graph(self) -> jsii.Number:
        ...

    @node_index_in_graph.setter
    def node_index_in_graph(self, value: jsii.Number) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="nodeName")
    def node_name(self) -> builtins.str:
        ...

    @node_name.setter
    def node_name(self, value: builtins.str) -> None:
        ...


class _IOperationNodeInstructionsProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IOperationNodeInstructions"

    @builtins.property
    @jsii.member(jsii_name="instructions")
    def instructions(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "instructions"))

    @instructions.setter
    def instructions(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5029eec55150a99d387bd33a241844941678a723123f576ab5ca1dbe8560ac7f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instructions", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="nodeIndexInGraph")
    def node_index_in_graph(self) -> jsii.Number:
        return typing.cast(jsii.Number, jsii.get(self, "nodeIndexInGraph"))

    @node_index_in_graph.setter
    def node_index_in_graph(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__64a691e85b135dcb7a3455055b40b75c9fd087eccfa1e4530a0d3b72f8779ae8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "nodeIndexInGraph", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="nodeName")
    def node_name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "nodeName"))

    @node_name.setter
    def node_name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__734c9db79aa3475cc0b924e42ac63aa8d52b10288609ab049f61de3218eb4e27)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "nodeName", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IOperationNodeInstructions).__jsii_proxy_class__ = lambda : _IOperationNodeInstructionsProxy


@jsii.interface(jsii_type="xpander-sdk.IPGSchema")
class IPGSchema(typing_extensions.Protocol):
    '''Represents a schema group for a prompt group session (PGSchema), containing multiple node schemas.'''

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        ...

    @builtins.property
    @jsii.member(jsii_name="schemas")
    def schemas(self) -> typing.List[INodeSchema]:
        ...


class _IPGSchemaProxy:
    '''Represents a schema group for a prompt group session (PGSchema), containing multiple node schemas.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IPGSchema"

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @builtins.property
    @jsii.member(jsii_name="schemas")
    def schemas(self) -> typing.List[INodeSchema]:
        return typing.cast(typing.List[INodeSchema], jsii.get(self, "schemas"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPGSchema).__jsii_proxy_class__ = lambda : _IPGSchemaProxy


@jsii.interface(jsii_type="xpander-sdk.ISourceNode")
class ISourceNode(typing_extensions.Protocol):
    '''Interface representing a source node in the agent's graph.'''

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''Unique identifier for the source node.'''
        ...

    @id.setter
    def id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="metadata")
    def metadata(self) -> typing.Any:
        '''Metadata associated with the source node.'''
        ...

    @metadata.setter
    def metadata(self, value: typing.Any) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> "SourceNodeType":
        '''Type of the source node (e.g., SDK, TASK).'''
        ...

    @type.setter
    def type(self, value: "SourceNodeType") -> None:
        ...


class _ISourceNodeProxy:
    '''Interface representing a source node in the agent's graph.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.ISourceNode"

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''Unique identifier for the source node.'''
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @id.setter
    def id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f6782cb166f668691a7b4be7b743380ed50722ee1549291808eee66d6a811fed)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="metadata")
    def metadata(self) -> typing.Any:
        '''Metadata associated with the source node.'''
        return typing.cast(typing.Any, jsii.get(self, "metadata"))

    @metadata.setter
    def metadata(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ebf5d7d569b37ac0c974cabb49c4e85f99273856f9fc2bdac40d66bc3412561d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "metadata", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> "SourceNodeType":
        '''Type of the source node (e.g., SDK, TASK).'''
        return typing.cast("SourceNodeType", jsii.get(self, "type"))

    @type.setter
    def type(self, value: "SourceNodeType") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3b0db8ab6f32bead8676f5d65edb0c8465aea43ef940f7b1d7b2ba9d2d577c39)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ISourceNode).__jsii_proxy_class__ = lambda : _ISourceNodeProxy


@jsii.interface(jsii_type="xpander-sdk.ITool")
class ITool(typing_extensions.Protocol):
    '''Interface representing a general tool.'''

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''A description of the tool's functionality.'''
        ...

    @description.setter
    def description(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the tool.'''
        ...

    @name.setter
    def name(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="func")
    def func(self) -> typing.Any:
        '''Function to execute the tool's logic.'''
        ...

    @func.setter
    def func(self, value: typing.Any) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "IToolParameter"]]:
        '''Parameters required by the tool.'''
        ...

    @parameters.setter
    def parameters(
        self,
        value: typing.Optional[typing.Mapping[builtins.str, "IToolParameter"]],
    ) -> None:
        ...


class _IToolProxy:
    '''Interface representing a general tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.ITool"

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''A description of the tool's functionality.'''
        return typing.cast(builtins.str, jsii.get(self, "description"))

    @description.setter
    def description(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5f56ea2b548b4cdfe22f0f80bf2c3f88697c04aedd2bf7fe61755b4eb9cee55b)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''The name of the tool.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5396ff1ffb06161e7b92840a35a663b1f418ffdcc7dde0e2593addf6ca31936a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="func")
    def func(self) -> typing.Any:
        '''Function to execute the tool's logic.'''
        return typing.cast(typing.Any, jsii.get(self, "func"))

    @func.setter
    def func(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__682720a04a90eb0d29239c0baf8e36b53b239f76f1079edf9cd418a69ddb97ac)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "func", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, "IToolParameter"]]:
        '''Parameters required by the tool.'''
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, "IToolParameter"]], jsii.get(self, "parameters"))

    @parameters.setter
    def parameters(
        self,
        value: typing.Optional[typing.Mapping[builtins.str, "IToolParameter"]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0bf23d7676e5d1c7e307b10d99651d3e323b4741175a001eec3d04daa9f6a063)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "parameters", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITool).__jsii_proxy_class__ = lambda : _IToolProxy


@jsii.interface(jsii_type="xpander-sdk.IToolCall")
class IToolCall(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        ...

    @name.setter
    def name(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="toolCallId")
    def tool_call_id(self) -> builtins.str:
        ...

    @tool_call_id.setter
    def tool_call_id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="payload")
    def payload(self) -> typing.Optional[builtins.str]:
        ...

    @payload.setter
    def payload(self, value: typing.Optional[builtins.str]) -> None:
        ...


class _IToolCallProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IToolCall"

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5219f06879c23f3e080fc36ccd3ecf3404dfc6994def97d5e4ec94ce59d72bb7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="toolCallId")
    def tool_call_id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "toolCallId"))

    @tool_call_id.setter
    def tool_call_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__039a35d67dfcf0e4fcf0d24c95fae7adcb68a33fbc193c12840c321781f41670)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "toolCallId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="payload")
    def payload(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "payload"))

    @payload.setter
    def payload(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4c4f34dbc98830433192bba8d2c699a1cb8148d1491b27977e6d346e261fb913)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "payload", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IToolCall).__jsii_proxy_class__ = lambda : _IToolCallProxy


@jsii.interface(jsii_type="xpander-sdk.IToolCallPayload")
class IToolCallPayload(typing_extensions.Protocol):
    '''Interface representing the payload for a tool call.'''

    @builtins.property
    @jsii.member(jsii_name="bodyParams")
    def body_params(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''Parameters for the request body.'''
        ...

    @body_params.setter
    def body_params(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="headers")
    def headers(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''Headers for the tool call request.'''
        ...

    @headers.setter
    def headers(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="pathParams")
    def path_params(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''Parameters for the URL path.'''
        ...

    @path_params.setter
    def path_params(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="queryParams")
    def query_params(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''Parameters for the URL query string.'''
        ...

    @query_params.setter
    def query_params(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        ...


class _IToolCallPayloadProxy:
    '''Interface representing the payload for a tool call.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IToolCallPayload"

    @builtins.property
    @jsii.member(jsii_name="bodyParams")
    def body_params(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''Parameters for the request body.'''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "bodyParams"))

    @body_params.setter
    def body_params(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c9832f75123fcf9d9b942f4c173edc15dd68204b28ad5d4260488d6c5c649f9e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "bodyParams", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="headers")
    def headers(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''Headers for the tool call request.'''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "headers"))

    @headers.setter
    def headers(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a367c116b987fb49136a9814177e4d056c61593dd022f63355bb894da7fc9988)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "headers", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="pathParams")
    def path_params(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''Parameters for the URL path.'''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "pathParams"))

    @path_params.setter
    def path_params(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e21845a97036e31f029489182b71f645274dafcc99c56e102732ed75019f377)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "pathParams", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="queryParams")
    def query_params(self) -> typing.Mapping[builtins.str, typing.Any]:
        '''Parameters for the URL query string.'''
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "queryParams"))

    @query_params.setter
    def query_params(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__893f015e220df05bf7b08ec5d24e2064db840604744494f599f33b596f114ee0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "queryParams", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IToolCallPayload).__jsii_proxy_class__ = lambda : _IToolCallPayloadProxy


@jsii.interface(jsii_type="xpander-sdk.IToolExecutionResult")
class IToolExecutionResult(typing_extensions.Protocol):
    '''Represents the result of a tool execution, including status, data, and success indicator.'''

    @builtins.property
    @jsii.member(jsii_name="data")
    def data(self) -> typing.Any:
        ...

    @data.setter
    def data(self, value: typing.Any) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="headers")
    def headers(self) -> typing.Mapping[builtins.str, typing.Any]:
        ...

    @headers.setter
    def headers(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="isSuccess")
    def is_success(self) -> builtins.bool:
        ...

    @is_success.setter
    def is_success(self, value: builtins.bool) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="statusCode")
    def status_code(self) -> jsii.Number:
        ...

    @status_code.setter
    def status_code(self, value: jsii.Number) -> None:
        ...


class _IToolExecutionResultProxy:
    '''Represents the result of a tool execution, including status, data, and success indicator.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IToolExecutionResult"

    @builtins.property
    @jsii.member(jsii_name="data")
    def data(self) -> typing.Any:
        return typing.cast(typing.Any, jsii.get(self, "data"))

    @data.setter
    def data(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a45442afc737189c680b610029e36c0388f812ca6addfc20d90f2255236a7a1d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "data", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="headers")
    def headers(self) -> typing.Mapping[builtins.str, typing.Any]:
        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "headers"))

    @headers.setter
    def headers(self, value: typing.Mapping[builtins.str, typing.Any]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f74a57170964ac6f2225d4a42e688907f1b3fc6d5dcc4cefae60ba4c69e6a205)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "headers", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="isSuccess")
    def is_success(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "isSuccess"))

    @is_success.setter
    def is_success(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0f354465848d57d08212584493a7b8ebb70e6a4185a12514d09d39089267cc34)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "isSuccess", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="statusCode")
    def status_code(self) -> jsii.Number:
        return typing.cast(jsii.Number, jsii.get(self, "statusCode"))

    @status_code.setter
    def status_code(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd332b88cb4f7bb75ce8e88200df9b702232ca7807d466896031bba1bac55a15)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "statusCode", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IToolExecutionResult).__jsii_proxy_class__ = lambda : _IToolExecutionResultProxy


@jsii.interface(jsii_type="xpander-sdk.IToolInstructions")
class IToolInstructions(typing_extensions.Protocol):
    '''Interface representing instructions for a tool.'''

    @builtins.property
    @jsii.member(jsii_name="functionDescription")
    def function_description(self) -> builtins.str:
        '''Description of the tool's function.'''
        ...

    @function_description.setter
    def function_description(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''Identifier for the tool.'''
        ...

    @id.setter
    def id(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(self) -> typing.Any:
        '''Parameters required by the tool.'''
        ...

    @parameters.setter
    def parameters(self, value: typing.Any) -> None:
        ...


class _IToolInstructionsProxy:
    '''Interface representing instructions for a tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IToolInstructions"

    @builtins.property
    @jsii.member(jsii_name="functionDescription")
    def function_description(self) -> builtins.str:
        '''Description of the tool's function.'''
        return typing.cast(builtins.str, jsii.get(self, "functionDescription"))

    @function_description.setter
    def function_description(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bbdc5a25cd119bc40de0970a3da5a996792b481e3623e5692f2220f66858eaff)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "functionDescription", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''Identifier for the tool.'''
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @id.setter
    def id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__116d46c0c30294630e565344bb001679a311f6d4bdf7fde9def35de5f5e69bff)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="parameters")
    def parameters(self) -> typing.Any:
        '''Parameters required by the tool.'''
        return typing.cast(typing.Any, jsii.get(self, "parameters"))

    @parameters.setter
    def parameters(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__09181db93f9b9267ab92d06c025f7bac4699c1fdac9ca798c651a63559aa913f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "parameters", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IToolInstructions).__jsii_proxy_class__ = lambda : _IToolInstructionsProxy


@jsii.interface(jsii_type="xpander-sdk.IToolParameter")
class IToolParameter(typing_extensions.Protocol):
    '''Interface representing a parameter for a tool.'''

    @builtins.property
    @jsii.member(jsii_name="properties")
    def properties(self) -> typing.Mapping[builtins.str, "IToolParameter"]:
        '''Properties of the parameter, if it is an object type.'''
        ...

    @properties.setter
    def properties(self, value: typing.Mapping[builtins.str, "IToolParameter"]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''The type of the parameter (e.g., string, object).'''
        ...

    @type.setter
    def type(self, value: builtins.str) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="required")
    def required(self) -> typing.Optional[typing.List[builtins.str]]:
        '''List of required properties within this parameter, if any.'''
        ...

    @required.setter
    def required(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        ...


class _IToolParameterProxy:
    '''Interface representing a parameter for a tool.'''

    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IToolParameter"

    @builtins.property
    @jsii.member(jsii_name="properties")
    def properties(self) -> typing.Mapping[builtins.str, IToolParameter]:
        '''Properties of the parameter, if it is an object type.'''
        return typing.cast(typing.Mapping[builtins.str, IToolParameter], jsii.get(self, "properties"))

    @properties.setter
    def properties(self, value: typing.Mapping[builtins.str, IToolParameter]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__187dae4a63a6fee1ee6e1cb395b2f91742bd245c20c13ab04570590726c5ef61)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "properties", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> builtins.str:
        '''The type of the parameter (e.g., string, object).'''
        return typing.cast(builtins.str, jsii.get(self, "type"))

    @type.setter
    def type(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__16039ce6185f742cd5865e412fc0342905a7a6d458331abeea0c8aea52fd0eb5)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="required")
    def required(self) -> typing.Optional[typing.List[builtins.str]]:
        '''List of required properties within this parameter, if any.'''
        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "required"))

    @required.setter
    def required(self, value: typing.Optional[typing.List[builtins.str]]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__52b13164b7161ac045d14f7c4212e2fc304cf9b4c0234c2221c11807a860fee0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "required", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IToolParameter).__jsii_proxy_class__ = lambda : _IToolParameterProxy


@jsii.interface(jsii_type="xpander-sdk.IUserDetails")
class IUserDetails(typing_extensions.Protocol):
    @builtins.property
    @jsii.member(jsii_name="additionalAttributes")
    def additional_attributes(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        ...

    @additional_attributes.setter
    def additional_attributes(
        self,
        value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
    ) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="email")
    def email(self) -> typing.Optional[builtins.str]:
        ...

    @email.setter
    def email(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="firstName")
    def first_name(self) -> typing.Optional[builtins.str]:
        ...

    @first_name.setter
    def first_name(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> typing.Optional[builtins.str]:
        ...

    @id.setter
    def id(self, value: typing.Optional[builtins.str]) -> None:
        ...

    @builtins.property
    @jsii.member(jsii_name="lastName")
    def last_name(self) -> typing.Optional[builtins.str]:
        ...

    @last_name.setter
    def last_name(self, value: typing.Optional[builtins.str]) -> None:
        ...


class _IUserDetailsProxy:
    __jsii_type__: typing.ClassVar[str] = "xpander-sdk.IUserDetails"

    @builtins.property
    @jsii.member(jsii_name="additionalAttributes")
    def additional_attributes(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "additionalAttributes"))

    @additional_attributes.setter
    def additional_attributes(
        self,
        value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__10f4d4aba0d7589de631b80acf65044a45841cfafe8c7f4fd9a1226e9f3be468)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "additionalAttributes", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="email")
    def email(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "email"))

    @email.setter
    def email(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9fe6b035e53bc42a7e87bae4d7e9b65a2f04ef7a3d9e58cbe7b7a94d3e662c9c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "email", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="firstName")
    def first_name(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "firstName"))

    @first_name.setter
    def first_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4ba223916284512961bbbf6e5b504fd43d4938ff7a56f95398d6624ef8b015e1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "firstName", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "id"))

    @id.setter
    def id(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec5dcae8ec16cbd97f348dd46db610a14b3790249f32a3039c3b6acb9791d2e3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="lastName")
    def last_name(self) -> typing.Optional[builtins.str]:
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "lastName"))

    @last_name.setter
    def last_name(self, value: typing.Optional[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__29613433172fd0f0dad44d9ee32b672116fbcf25f67f6f9a07db1b772585b2e8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "lastName", value) # pyright: ignore[reportArgumentType]

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IUserDetails).__jsii_proxy_class__ = lambda : _IUserDetailsProxy


class KnowledgeBase(
    Base,
    metaclass=jsii.JSIIMeta,
    jsii_type="xpander-sdk.KnowledgeBase",
):
    def __init__(
        self,
        id: builtins.str,
        name: builtins.str,
        description: builtins.str,
        strategy: "KnowledgeBaseStrategy",
        documents: typing.Sequence[builtins.str],
    ) -> None:
        '''
        :param id: -
        :param name: -
        :param description: -
        :param strategy: -
        :param documents: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__51e3a6f2086f6f694ae00811d3c8cfbc7998d5e84bc5e953097d209d2b1d9e8e)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument strategy", value=strategy, expected_type=type_hints["strategy"])
            check_type(argname="argument documents", value=documents, expected_type=type_hints["documents"])
        jsii.create(self.__class__, self, [id, name, description, strategy, documents])

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "description"))

    @description.setter
    def description(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b5346ca86b97d9beb023662f6917773322c22dd333b4088d0a3e1aa3f9b863f1)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "description", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="documents")
    def documents(self) -> typing.List[builtins.str]:
        return typing.cast(typing.List[builtins.str], jsii.get(self, "documents"))

    @documents.setter
    def documents(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f91030cf0630f559d66490e3f6115e32fa737afa26a254c624598a4473424178)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "documents", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @id.setter
    def id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2b1a6bd536d05cb8f737d34d1a5470e5cbffbae2b7b39eabd405ec3a83750f39)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ec5f1b09e3bf37c8db0a7e8a770f79ae3a608fbcf53ae579ab368ca80ea281b2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="strategy")
    def strategy(self) -> "KnowledgeBaseStrategy":
        return typing.cast("KnowledgeBaseStrategy", jsii.get(self, "strategy"))

    @strategy.setter
    def strategy(self, value: "KnowledgeBaseStrategy") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c985cb1467f7bafe537bc1fe177d04bb3967730f168ac32ce862f8c3d39dbe95)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "strategy", value) # pyright: ignore[reportArgumentType]


@jsii.enum(jsii_type="xpander-sdk.KnowledgeBaseStrategy")
class KnowledgeBaseStrategy(enum.Enum):
    VANILLA = "VANILLA"
    AGENTIC_RAG = "AGENTIC_RAG"


@jsii.enum(jsii_type="xpander-sdk.LLMProvider")
class LLMProvider(enum.Enum):
    '''Enum representing different Large Language Model (LLM) providers.

    This enum lists various LLM service providers integrated with xpanderAI, enabling
    selection of the desired LLM provider for specific tasks.
    '''

    LANG_CHAIN = "LANG_CHAIN"
    '''Represents the 'langchain' provider.'''
    OPEN_AI = "OPEN_AI"
    '''Represents the 'openai' provider.'''
    REAL_TIME_OPEN_AI = "REAL_TIME_OPEN_AI"
    '''Represents the 'openai' provider.'''
    NVIDIA_NIM = "NVIDIA_NIM"
    '''Represents the 'nvidiaNim' provider.'''
    AMAZON_BEDROCK = "AMAZON_BEDROCK"
    '''Represents the 'amazonBedrock' provider.'''
    OLLAMA = "OLLAMA"
    '''Represents the 'ollama' provider.'''
    FRIENDLI_AI = "FRIENDLI_AI"
    '''Represents the 'FriendliAI' provider.'''


class Memory(Base, metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.Memory"):
    '''Represents a memory thread in xpanderAI, handling storage, retrieval, and processing of memory messages and related operations.'''

    def __init__(
        self,
        agent: "Agent",
        id: builtins.str,
        messages: typing.Sequence[IMemoryMessage],
        user_details: builtins.str,
        memory_type: "MemoryType",
    ) -> None:
        '''
        :param agent: -
        :param id: -
        :param messages: -
        :param user_details: -
        :param memory_type: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__81920271697ae42e098719be39b49bcd21415f983a883772a893c601ddaee6dd)
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument messages", value=messages, expected_type=type_hints["messages"])
            check_type(argname="argument user_details", value=user_details, expected_type=type_hints["user_details"])
            check_type(argname="argument memory_type", value=memory_type, expected_type=type_hints["memory_type"])
        jsii.create(self.__class__, self, [agent, id, messages, user_details, memory_type])

    @jsii.member(jsii_name="create")
    @builtins.classmethod
    def create(
        cls,
        agent: "Agent",
        user_details: typing.Optional[IUserDetails] = None,
    ) -> "Memory":
        '''Creates a new memory thread for the specified agent.

        :param agent: - The agent for which the memory thread is created.
        :param user_details: - Optional user details associated with the memory thread.

        :return: A new instance of the Memory class.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__aac0cdf9d3941968c7d1fb460252d03479b6f845bc6ba305a0180fce4bcdb71b)
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
            check_type(argname="argument user_details", value=user_details, expected_type=type_hints["user_details"])
        return typing.cast("Memory", jsii.sinvoke(cls, "create", [agent, user_details]))

    @jsii.member(jsii_name="fetch")
    @builtins.classmethod
    def fetch(cls, agent: "Agent", thread_id: builtins.str) -> "Memory":
        '''Fetches an existing memory thread by its ID.

        :param agent: - The agent associated with the memory thread.
        :param thread_id: - The ID of the memory thread to fetch.

        :return: An instance of the Memory class representing the fetched thread.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5e2e59e4d3fb03b2220fd16d51c1c03d26c81217aecbc900c19d672d4777df78)
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
            check_type(argname="argument thread_id", value=thread_id, expected_type=type_hints["thread_id"])
        return typing.cast("Memory", jsii.sinvoke(cls, "fetch", [agent, thread_id]))

    @jsii.member(jsii_name="addMessages")
    def add_messages(self, _messages: typing.Any) -> None:
        '''Adds messages to the memory thread.

        Converts non-standard messages to a compatible format before storing.

        :param _messages: - An array of messages to be added to the memory thread.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1a51857d33f65b0aeb1e47a32821416678e02e9977e28bcf191def00e1de1385)
            check_type(argname="argument _messages", value=_messages, expected_type=type_hints["_messages"])
        return typing.cast(None, jsii.invoke(self, "addMessages", [_messages]))

    @jsii.member(jsii_name="addToolCallResults")
    def add_tool_call_results(
        self,
        tool_call_results: typing.Sequence["ToolCallResult"],
    ) -> None:
        '''Adds tool call results as messages to the memory thread.

        :param tool_call_results: - An array of tool call results to be added as messages.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__371bbac48ab4303b8878745ba398512a7e9b2282fcdf6e8b9dd183b48b03488e)
            check_type(argname="argument tool_call_results", value=tool_call_results, expected_type=type_hints["tool_call_results"])
        return typing.cast(None, jsii.invoke(self, "addToolCallResults", [tool_call_results]))

    @jsii.member(jsii_name="initializeThread")
    def initialize_thread(
        self,
        input: IMemoryMessage,
        instructions: IAgentInstructions,
    ) -> None:
        '''Initializes a new memory thread with input and instructions.

        :param input: - Initial user input message.
        :param instructions: - Instructions to initialize the memory thread.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0bdc7533e91a9993a0ae547e0986d3f0f7baf1f8fde5221f829e8393cd5e222f)
            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
            check_type(argname="argument instructions", value=instructions, expected_type=type_hints["instructions"])
        return typing.cast(None, jsii.invoke(self, "initializeThread", [input, instructions]))

    @jsii.member(jsii_name="initInstructions")
    def init_instructions(self, instructions: IAgentInstructions) -> None:
        '''Initializes the memory thread with system instructions if no messages exist.

        :param instructions: - Instructions to initialize the memory thread.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6ce51eb3bc0f66424dc100907e6b8645a78f014da089334b5683929638780555)
            check_type(argname="argument instructions", value=instructions, expected_type=type_hints["instructions"])
        return typing.cast(None, jsii.invoke(self, "initInstructions", [instructions]))

    @jsii.member(jsii_name="retrieveMessages")
    def retrieve_messages(self) -> typing.List[typing.Any]:
        '''Retrieves the messages stored in the memory thread.

        Applies the agent's memory strategy to refresh the messages if needed.

        :return: An array of messages formatted for the selected LLM provider.
        '''
        return typing.cast(typing.List[typing.Any], jsii.invoke(self, "retrieveMessages", []))

    @jsii.member(jsii_name="selectLLMProvider")
    def select_llm_provider(self, llm_provider: LLMProvider) -> None:
        '''Sets the LLM provider for processing memory messages.

        :param llm_provider: - The LLM provider to use.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c90de86ece903a3b93c8f19a918abf58c99227e7ca07b62b12149ae4d1d1f942)
            check_type(argname="argument llm_provider", value=llm_provider, expected_type=type_hints["llm_provider"])
        return typing.cast(None, jsii.invoke(self, "selectLLMProvider", [llm_provider]))

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @id.setter
    def id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bbe18b88e2660e8696c14f8f8e6d7a160be4e10f351309c88ad1ef59993830d2)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="llmProvider")
    def llm_provider(self) -> LLMProvider:
        '''The LLM provider to be used for message processing.'''
        return typing.cast(LLMProvider, jsii.get(self, "llmProvider"))

    @llm_provider.setter
    def llm_provider(self, value: LLMProvider) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__480c9de0d56a727b6080606ffa19389e9a950f96e37f7f9a97200fd43981ce7f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "llmProvider", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="memoryType")
    def memory_type(self) -> "MemoryType":
        return typing.cast("MemoryType", jsii.get(self, "memoryType"))

    @memory_type.setter
    def memory_type(self, value: "MemoryType") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8b4f084a61d1e17795026fdf0d8050b34b2f09eea03d6dfbb5809384ca99e18c)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "memoryType", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="messages")
    def messages(self) -> typing.List[IMemoryMessage]:
        return typing.cast(typing.List[IMemoryMessage], jsii.get(self, "messages"))

    @messages.setter
    def messages(self, value: typing.List[IMemoryMessage]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__061b6a073f962d6437ad5fafa99b961231c85f17625aa93e208f2ab144777953)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "messages", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="userDetails")
    def user_details(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "userDetails"))

    @user_details.setter
    def user_details(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e929e79b7b59a892685c04ee233be1c732bd06c519447292cd87e096540451a8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "userDetails", value) # pyright: ignore[reportArgumentType]


@jsii.enum(jsii_type="xpander-sdk.MemoryStrategy")
class MemoryStrategy(enum.Enum):
    FULL = "FULL"
    SUMMARIZATION = "SUMMARIZATION"
    BUFFERING = "BUFFERING"
    MOVING_WINDOW = "MOVING_WINDOW"
    CONTEXT = "CONTEXT"


@jsii.enum(jsii_type="xpander-sdk.MemoryType")
class MemoryType(enum.Enum):
    LONG_TERM = "LONG_TERM"
    SHORT_TERM = "SHORT_TERM"


class NvidiaNIMSupportedModels(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="xpander-sdk.NvidiaNIMSupportedModels",
):
    '''Contains constants representing various models supported by Nvidia NIM.'''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="LLAMA_3_1_70B_INSTRUCT")
    def LLAMA_3_1_70_B_INSTRUCT(cls) -> builtins.str:
        '''Meta Llama 3.1 70B Instruct model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "LLAMA_3_1_70B_INSTRUCT"))


class _NvidiaNIMSupportedModelsProxy(NvidiaNIMSupportedModels):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, NvidiaNIMSupportedModels).__jsii_proxy_class__ = lambda : _NvidiaNIMSupportedModelsProxy


class OpenAISupportedModels(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="xpander-sdk.OpenAISupportedModels",
):
    '''Contains constants representing various models supported by OpenAI.'''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="GPT_4")
    def GPT_4(cls) -> builtins.str:
        '''OpenAI GPT-4 model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "GPT_4"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="GPT_4_O")
    def GPT_4_O(cls) -> builtins.str:
        '''OpenAI GPT-4o model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "GPT_4_O"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="GPT_4_O_MINI")
    def GPT_4_O_MINI(cls) -> builtins.str:
        '''OpenAI GPT-4o Mini model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "GPT_4_O_MINI"))


class _OpenAISupportedModelsProxy(OpenAISupportedModels):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, OpenAISupportedModels).__jsii_proxy_class__ = lambda : _OpenAISupportedModelsProxy


class RealTimeOpenAISupportedModels(
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="xpander-sdk.RealTimeOpenAISupportedModels",
):
    '''Contains constants representing various models supported by OpenAI.

    :remarks:

    This abstract class defines static constants for the supported models
    by xpanderAI's OpenAI real-time integrations.
    '''

    def __init__(self) -> None:
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="GPT_4_O_AUDIO_PREVIEW")
    def GPT_4_O_AUDIO_PREVIEW(cls) -> builtins.str:
        '''OpenAI GPT-4o Audio Preview model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "GPT_4_O_AUDIO_PREVIEW"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="GPT_4_O_REALTIME_PREVIEW")
    def GPT_4_O_REALTIME_PREVIEW(cls) -> builtins.str:
        '''OpenAI GPT-4o Realtime Preview model.'''
        return typing.cast(builtins.str, jsii.sget(cls, "GPT_4_O_REALTIME_PREVIEW"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="WHISPER_1")
    def WHISPER_1(cls) -> builtins.str:
        '''OpenAI Whisper model for speech-to-text tasks.'''
        return typing.cast(builtins.str, jsii.sget(cls, "WHISPER_1"))


class _RealTimeOpenAISupportedModelsProxy(RealTimeOpenAISupportedModels):
    pass

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, RealTimeOpenAISupportedModels).__jsii_proxy_class__ = lambda : _RealTimeOpenAISupportedModelsProxy


@jsii.enum(jsii_type="xpander-sdk.SourceNodeType")
class SourceNodeType(enum.Enum):
    '''Enum representing different source node types for agents.'''

    SDK = "SDK"
    TASK = "TASK"
    ASSISTANT = "ASSISTANT"
    WEBHOOK = "WEBHOOK"


class ToolCall(Base, metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.ToolCall"):
    def __init__(
        self,
        name: typing.Optional[builtins.str] = None,
        type: typing.Optional["ToolCallType"] = None,
        payload: typing.Any = None,
        tool_call_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param name: -
        :param type: -
        :param payload: -
        :param tool_call_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c5b1512c48e4c0a4b618d417e46f7c83b02989356f2412aa0eae9d63b626ce0e)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument payload", value=payload, expected_type=type_hints["payload"])
            check_type(argname="argument tool_call_id", value=tool_call_id, expected_type=type_hints["tool_call_id"])
        jsii.create(self.__class__, self, [name, type, payload, tool_call_id])

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c7cce041752b4e95ae25466ea39d32f51ec0301e64015b66ccf20bb9b23db25e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="payload")
    def payload(self) -> typing.Any:
        return typing.cast(typing.Any, jsii.get(self, "payload"))

    @payload.setter
    def payload(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c1940e09fdc14592acfce7003f99bcc770eb4b17ea62e53e30d6cbfd4d3d3707)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "payload", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="toolCallId")
    def tool_call_id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "toolCallId"))

    @tool_call_id.setter
    def tool_call_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__12d9b994824033489cb2b3b806044405bcb06c1d72048f017c89bb422b16b35e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "toolCallId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="type")
    def type(self) -> "ToolCallType":
        return typing.cast("ToolCallType", jsii.get(self, "type"))

    @type.setter
    def type(self, value: "ToolCallType") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2059ec549c7384dd73be7be379faf6256c60a8ec7b55fdb9082692bbdc4bac54)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "type", value) # pyright: ignore[reportArgumentType]


class ToolCallResult(
    Base,
    metaclass=jsii.JSIIMeta,
    jsii_type="xpander-sdk.ToolCallResult",
):
    def __init__(
        self,
        function_name: typing.Optional[builtins.str] = None,
        tool_call_id: typing.Optional[builtins.str] = None,
        payload: typing.Any = None,
        status_code: typing.Optional[jsii.Number] = None,
        result: typing.Any = None,
        is_success: typing.Optional[builtins.bool] = None,
        is_error: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param function_name: -
        :param tool_call_id: -
        :param payload: -
        :param status_code: -
        :param result: -
        :param is_success: -
        :param is_error: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2debc725768136a46976eacab873877fdcc3efbb47c357e0973193213896e283)
            check_type(argname="argument function_name", value=function_name, expected_type=type_hints["function_name"])
            check_type(argname="argument tool_call_id", value=tool_call_id, expected_type=type_hints["tool_call_id"])
            check_type(argname="argument payload", value=payload, expected_type=type_hints["payload"])
            check_type(argname="argument status_code", value=status_code, expected_type=type_hints["status_code"])
            check_type(argname="argument result", value=result, expected_type=type_hints["result"])
            check_type(argname="argument is_success", value=is_success, expected_type=type_hints["is_success"])
            check_type(argname="argument is_error", value=is_error, expected_type=type_hints["is_error"])
        jsii.create(self.__class__, self, [function_name, tool_call_id, payload, status_code, result, is_success, is_error])

    @builtins.property
    @jsii.member(jsii_name="functionName")
    def function_name(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "functionName"))

    @function_name.setter
    def function_name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3fffc9823e52bc6b5b2f4aa72f7ed94614aad7d55b77f29de8574547aa73f28f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "functionName", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="isError")
    def is_error(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "isError"))

    @is_error.setter
    def is_error(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e12e85757c6557cdf77248e76a660df04102b8873b38236827fb882d1fa6439a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "isError", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="isSuccess")
    def is_success(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "isSuccess"))

    @is_success.setter
    def is_success(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e0ae8339ae925874f36d96caaf593a776e69a5def415e6cd597660d7e9c011e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "isSuccess", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="payload")
    def payload(self) -> typing.Any:
        return typing.cast(typing.Any, jsii.get(self, "payload"))

    @payload.setter
    def payload(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d2de087a3432f7b811bf4e98dd110380b61cb2d0cdcd014af55ea9c493c5e516)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "payload", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="result")
    def result(self) -> typing.Any:
        return typing.cast(typing.Any, jsii.get(self, "result"))

    @result.setter
    def result(self, value: typing.Any) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8b512e8cc2e3d13362bf29e552b8dff26b147cd4cf7b3fc2ac09efd5bd6e5bd8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "result", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="statusCode")
    def status_code(self) -> jsii.Number:
        return typing.cast(jsii.Number, jsii.get(self, "statusCode"))

    @status_code.setter
    def status_code(self, value: jsii.Number) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2d7de4c43b1bcc39cb1dbd154a581a3c2a35f429555b50d12f81d0c6662c787a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "statusCode", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="toolCallId")
    def tool_call_id(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "toolCallId"))

    @tool_call_id.setter
    def tool_call_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e548be6ee41a966ad4e21e38458b2dc18fde679b9017e65e4f088b5b0d8c3580)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "toolCallId", value) # pyright: ignore[reportArgumentType]


@jsii.enum(jsii_type="xpander-sdk.ToolCallType")
class ToolCallType(enum.Enum):
    '''Enum representing types of tool calls.'''

    XPANDER = "XPANDER"
    LOCAL = "LOCAL"


class XpanderClient(metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.XpanderClient"):
    '''XpanderClient provides methods for configuring and interacting with xpanderAI tools, managing agents, and extracting tool calls from LLM responses.'''

    def __init__(
        self,
        api_key: builtins.str,
        base_url: typing.Any = None,
        with_metrics_report: typing.Optional[builtins.bool] = None,
        organization_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''Constructs a new XpanderClient instance.

        :param api_key: -
        :param base_url: -
        :param with_metrics_report: -
        :param organization_id: -

        :throws: Will throw an error if an invalid API key is specified.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2ada04f0df01e9b462e0b973aee5f69eda17ab0f22e7345f33423f0acca9ad36)
            check_type(argname="argument api_key", value=api_key, expected_type=type_hints["api_key"])
            check_type(argname="argument base_url", value=base_url, expected_type=type_hints["base_url"])
            check_type(argname="argument with_metrics_report", value=with_metrics_report, expected_type=type_hints["with_metrics_report"])
            check_type(argname="argument organization_id", value=organization_id, expected_type=type_hints["organization_id"])
        jsii.create(self.__class__, self, [api_key, base_url, with_metrics_report, organization_id])

    @jsii.member(jsii_name="extractToolCalls")
    @builtins.classmethod
    def extract_tool_calls(
        cls,
        llm_response: typing.Any,
        llm_provider: typing.Optional[LLMProvider] = None,
    ) -> typing.List[ToolCall]:
        '''Extracts tool calls from an LLM response based on the specified LLM provider.

        :param llm_response: - The LLM response to analyze for tool calls.
        :param llm_provider: - The LLM provider, defaults to OPEN_AI.

        :return: An array of tool calls extracted from the LLM response.

        :throws: Error if the specified LLM provider is not supported.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d89a5c88d1a2ed62ab765c38358d4adda81980f27657e34b4fe23fc61eca9217)
            check_type(argname="argument llm_response", value=llm_response, expected_type=type_hints["llm_response"])
            check_type(argname="argument llm_provider", value=llm_provider, expected_type=type_hints["llm_provider"])
        return typing.cast(typing.List[ToolCall], jsii.sinvoke(cls, "extractToolCalls", [llm_response, llm_provider]))

    @builtins.property
    @jsii.member(jsii_name="agents")
    def agents(self) -> Agents:
        '''Instance of Agents to manage xpanderAI agents.'''
        return typing.cast(Agents, jsii.get(self, "agents"))

    @agents.setter
    def agents(self, value: Agents) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__50de96ce44613a7f9044134d55c384c9cbc69918873535eed55a2d9c1f2cafbd)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "agents", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="configuration")
    def configuration(self) -> Configuration:
        '''Configuration settings for the xpanderAI client.'''
        return typing.cast(Configuration, jsii.get(self, "configuration"))

    @configuration.setter
    def configuration(self, value: Configuration) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0f24bf46a0a96d6e069bcfdce151aa22264da15a80125c376dbad457bf91d1c0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "configuration", value) # pyright: ignore[reportArgumentType]


class Agent(Base, metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.Agent"):
    '''Represents an agent in xpanderAI, managing tools, sessions, and operational workflows.

    This class facilitates loading agents, handling tool executions, and managing prompt groups.
    '''

    def __init__(
        self,
        configuration: Configuration,
        id: builtins.str,
        name: builtins.str,
        organization_id: builtins.str,
        status: AgentStatus,
        memory_type: MemoryType,
        memory_strategy: MemoryStrategy,
        instructions: IAgentInstructions,
        access_scope: AgentAccessScope,
        source_nodes: typing.Sequence[ISourceNode],
        prompts: typing.Sequence[builtins.str],
        tools: typing.Optional[typing.Sequence[IAgentTool]] = None,
        graph: typing.Optional[typing.Sequence[IAgentGraphItem]] = None,
        knowledge_bases: typing.Optional[typing.Sequence[KnowledgeBase]] = None,
    ) -> None:
        '''Constructs a new Agent instance.

        :param configuration: - Configuration settings for the agent.
        :param id: - Unique identifier for the agent.
        :param name: - Human-readable name of the agent.
        :param organization_id: - Organization ID to which the agent belongs.
        :param status: - Current status of the agent.
        :param memory_type: - Type of memory the agent utilizes.
        :param memory_strategy: - Strategy for memory management.
        :param instructions: - Instructions for the agent's operation.
        :param access_scope: - Scope of the agent's access permissions.
        :param source_nodes: - Source nodes associated with the agent.
        :param prompts: - Prompts used by the agent.
        :param tools: - Tools available to the agent.
        :param graph: - Graph structure representing the agent's operational flow.
        :param knowledge_bases: - Knowledge bases associated with the agent.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ed3ca6ba27cec860aa869deb2eaf5d80822747214c50652c074c1fd995c12295)
            check_type(argname="argument configuration", value=configuration, expected_type=type_hints["configuration"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument organization_id", value=organization_id, expected_type=type_hints["organization_id"])
            check_type(argname="argument status", value=status, expected_type=type_hints["status"])
            check_type(argname="argument memory_type", value=memory_type, expected_type=type_hints["memory_type"])
            check_type(argname="argument memory_strategy", value=memory_strategy, expected_type=type_hints["memory_strategy"])
            check_type(argname="argument instructions", value=instructions, expected_type=type_hints["instructions"])
            check_type(argname="argument access_scope", value=access_scope, expected_type=type_hints["access_scope"])
            check_type(argname="argument source_nodes", value=source_nodes, expected_type=type_hints["source_nodes"])
            check_type(argname="argument prompts", value=prompts, expected_type=type_hints["prompts"])
            check_type(argname="argument tools", value=tools, expected_type=type_hints["tools"])
            check_type(argname="argument graph", value=graph, expected_type=type_hints["graph"])
            check_type(argname="argument knowledge_bases", value=knowledge_bases, expected_type=type_hints["knowledge_bases"])
        jsii.create(self.__class__, self, [configuration, id, name, organization_id, status, memory_type, memory_strategy, instructions, access_scope, source_nodes, prompts, tools, graph, knowledge_bases])

    @jsii.member(jsii_name="addLocalTools")
    def add_local_tools(
        self,
        tools: typing.Union[typing.Sequence[typing.Any], typing.Sequence[ILocalTool]],
    ) -> None:
        '''Adds local tools to the agent with prefixed function names.

        :param tools: - The list of local tools to add.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b1a4e9d238bcd6575542fe126282fe717dabbed97bd4b5d5f0906439f6debd49)
            check_type(argname="argument tools", value=tools, expected_type=type_hints["tools"])
        return typing.cast(None, jsii.invoke(self, "addLocalTools", [tools]))

    @jsii.member(jsii_name="getTools")
    def get_tools(
        self,
        llm_provider: typing.Optional[LLMProvider] = None,
    ) -> typing.List[typing.Any]:
        '''Retrieves tools compatible with a specified LLM provider.

        :param llm_provider: - The LLM provider to filter tools by (default: ``OPEN_AI``).

        :return: A list of tools matching the specified provider.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__773e3afa26f8b79fe00973c69c9983fbf523bfd2f52c02c0a473df8878934452)
            check_type(argname="argument llm_provider", value=llm_provider, expected_type=type_hints["llm_provider"])
        return typing.cast(typing.List[typing.Any], jsii.invoke(self, "getTools", [llm_provider]))

    @jsii.member(jsii_name="initTask")
    def init_task(self, execution: typing.Any) -> None:
        '''Initializes the task execution for the agent.

        :param execution: - The execution details.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__16872029ef2ca9a4aea1671c278ba6987a5be977e7311f29693d64313ecee69b)
            check_type(argname="argument execution", value=execution, expected_type=type_hints["execution"])
        return typing.cast(None, jsii.invoke(self, "initTask", [execution]))

    @jsii.member(jsii_name="isFinished")
    def is_finished(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.invoke(self, "isFinished", []))

    @jsii.member(jsii_name="load")
    def load(self) -> None:
        '''Loads the agent data from its source node type.'''
        return typing.cast(None, jsii.invoke(self, "load", []))

    @jsii.member(jsii_name="retrieveNodeFromGraph")
    def retrieve_node_from_graph(
        self,
        item_id: builtins.str,
    ) -> typing.Optional[IAgentGraphItem]:
        '''Retrieves a node from the graph by its ID.

        :param item_id: - The ID of the graph node to retrieve.

        :return: The matching graph node, or undefined if not found.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b76974a0e120e8cf7b77d0deb9b609235bfbb31f7bb65ad41e928422ab50a6b3)
            check_type(argname="argument item_id", value=item_id, expected_type=type_hints["item_id"])
        return typing.cast(typing.Optional[IAgentGraphItem], jsii.invoke(self, "retrieveNodeFromGraph", [item_id]))

    @jsii.member(jsii_name="runTool")
    def run_tool(
        self,
        tool: ToolCall,
        payload_extension: typing.Any = None,
    ) -> ToolCallResult:
        '''Executes a single tool call and returns the result.

        :param tool: - The tool call to execute.
        :param payload_extension: - Additional payload data to merge.

        :return: The result of the tool execution.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0e1ca0e533f7a6dc6cf8465ad7809ba4a450abee064ca45429a80a258a5e2e65)
            check_type(argname="argument tool", value=tool, expected_type=type_hints["tool"])
            check_type(argname="argument payload_extension", value=payload_extension, expected_type=type_hints["payload_extension"])
        return typing.cast(ToolCallResult, jsii.invoke(self, "runTool", [tool, payload_extension]))

    @jsii.member(jsii_name="runTools")
    def run_tools(
        self,
        tool_calls: typing.Sequence[ToolCall],
        payload_extension: typing.Any = None,
    ) -> typing.List[ToolCallResult]:
        '''Executes multiple tool calls sequentially and returns their results.

        :param tool_calls: - The list of tool calls to execute.
        :param payload_extension: - Additional payload data to merge.

        :return: A list of results for each tool execution.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__307c287f13e8189f59310f2e5a43f33ebb271c35e1502a531966c06bbe13ef32)
            check_type(argname="argument tool_calls", value=tool_calls, expected_type=type_hints["tool_calls"])
            check_type(argname="argument payload_extension", value=payload_extension, expected_type=type_hints["payload_extension"])
        return typing.cast(typing.List[ToolCallResult], jsii.invoke(self, "runTools", [tool_calls, payload_extension]))

    @jsii.member(jsii_name="updateUserDetails")
    def update_user_details(self, user_details: typing.Any) -> None:
        '''Updates the user details for the agent.

        :param user_details: - The user details to update.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__83adb98120d61cd6e5328f2ce8718542d01899c0e61b507458cf4b016b21ae58)
            check_type(argname="argument user_details", value=user_details, expected_type=type_hints["user_details"])
        return typing.cast(None, jsii.invoke(self, "updateUserDetails", [user_details]))

    @builtins.property
    @jsii.member(jsii_name="hasKnowledgeBase")
    def has_knowledge_base(self) -> builtins.bool:
        '''Checks if the agent has an associated knowledge base.'''
        return typing.cast(builtins.bool, jsii.get(self, "hasKnowledgeBase"))

    @builtins.property
    @jsii.member(jsii_name="hasLocalTools")
    def has_local_tools(self) -> builtins.bool:
        '''Checks if the agent has local tools loaded.'''
        return typing.cast(builtins.bool, jsii.get(self, "hasLocalTools"))

    @builtins.property
    @jsii.member(jsii_name="knowledgeBaseStrategy")
    def knowledge_base_strategy(self) -> builtins.str:
        '''Retrieves the knowledge base strategy of the agent.'''
        return typing.cast(builtins.str, jsii.get(self, "knowledgeBaseStrategy"))

    @builtins.property
    @jsii.member(jsii_name="memory")
    def memory(self) -> Memory:
        '''Retrieves the memory instance for the agent.'''
        return typing.cast(Memory, jsii.get(self, "memory"))

    @builtins.property
    @jsii.member(jsii_name="sourceNodeType")
    def source_node_type(self) -> SourceNodeType:
        '''Retrieves the type of source node for the agent.'''
        return typing.cast(SourceNodeType, jsii.get(self, "sourceNodeType"))

    @builtins.property
    @jsii.member(jsii_name="url")
    def url(self) -> builtins.str:
        '''Constructs the API URL for this agent.'''
        return typing.cast(builtins.str, jsii.get(self, "url"))

    @builtins.property
    @jsii.member(jsii_name="accessScope")
    def access_scope(self) -> AgentAccessScope:
        '''- Scope of the agent's access permissions.'''
        return typing.cast(AgentAccessScope, jsii.get(self, "accessScope"))

    @access_scope.setter
    def access_scope(self, value: AgentAccessScope) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bcb6c11034237fb99d4afc18d0b8280c1e1f09ddaefe3eb074cf796e3b725e93)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "accessScope", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="configuration")
    def configuration(self) -> Configuration:
        '''- Configuration settings for the agent.'''
        return typing.cast(Configuration, jsii.get(self, "configuration"))

    @configuration.setter
    def configuration(self, value: Configuration) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2acddc917b6b415bc14dfb9a7094cbd1b0319e93c3c4b3298f8cb5d9ec8206a7)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "configuration", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="graph")
    def graph(self) -> typing.List[IAgentGraphItem]:
        '''- Graph structure representing the agent's operational flow.'''
        return typing.cast(typing.List[IAgentGraphItem], jsii.get(self, "graph"))

    @graph.setter
    def graph(self, value: typing.List[IAgentGraphItem]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__455c760f94e4fc5ed8c239f2c501ce6bf2eb3da9a89e20e6afdd569a617b8ab0)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "graph", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="id")
    def id(self) -> builtins.str:
        '''- Unique identifier for the agent.'''
        return typing.cast(builtins.str, jsii.get(self, "id"))

    @id.setter
    def id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e0b9d8c488cea43db21adbef0723558d2e632d07b3f9134efdeb872de791fa1d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "id", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="instructions")
    def instructions(self) -> IAgentInstructions:
        '''- Instructions for the agent's operation.'''
        return typing.cast(IAgentInstructions, jsii.get(self, "instructions"))

    @instructions.setter
    def instructions(self, value: IAgentInstructions) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__729aa75df9167864d69d977ed37c2a63fa4c55e59a6a6595769ebe73e9503771)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "instructions", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="knowledgeBases")
    def knowledge_bases(self) -> typing.List[KnowledgeBase]:
        '''- Knowledge bases associated with the agent.'''
        return typing.cast(typing.List[KnowledgeBase], jsii.get(self, "knowledgeBases"))

    @knowledge_bases.setter
    def knowledge_bases(self, value: typing.List[KnowledgeBase]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d560d33d3a8d9ab2d5d84adacd04b2b8a4d5a0db676c32684e81f32478d93eaa)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "knowledgeBases", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="localTools")
    def local_tools(self) -> typing.List[ILocalTool]:
        '''Collection of local tools specific to this agent.'''
        return typing.cast(typing.List[ILocalTool], jsii.get(self, "localTools"))

    @local_tools.setter
    def local_tools(self, value: typing.List[ILocalTool]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cdc78718c4e88ad0687034fec3393a9b0dd4518c626fe4c60d2244cefaadbe37)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "localTools", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="memoryStrategy")
    def memory_strategy(self) -> MemoryStrategy:
        '''- Strategy for memory management.'''
        return typing.cast(MemoryStrategy, jsii.get(self, "memoryStrategy"))

    @memory_strategy.setter
    def memory_strategy(self, value: MemoryStrategy) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f78a447686d7a170f7713415428aefc1544249c3da73e354d5f28a8917f689ae)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "memoryStrategy", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="memoryType")
    def memory_type(self) -> MemoryType:
        '''- Type of memory the agent utilizes.'''
        return typing.cast(MemoryType, jsii.get(self, "memoryType"))

    @memory_type.setter
    def memory_type(self, value: MemoryType) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__805f0dbb3034522e5cd382a8d7f7c31a544db0bd26e45b0915f5b060aec59bed)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "memoryType", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''- Human-readable name of the agent.'''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @name.setter
    def name(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__22da1a47b30804817cea4f52e46761946f71d0d3436d3236d8ab8bbd3f9a2364)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "name", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="organizationId")
    def organization_id(self) -> builtins.str:
        '''- Organization ID to which the agent belongs.'''
        return typing.cast(builtins.str, jsii.get(self, "organizationId"))

    @organization_id.setter
    def organization_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4b78331aeaf11efbf7d44a1bd4ce9783ac8b3be074090b3f146520a09bb2ff99)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "organizationId", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="originalToolNamesReMapping")
    def _original_tool_names_re_mapping(
        self,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''Maps original tool names to renamed versions for consistency.'''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "originalToolNamesReMapping"))

    @_original_tool_names_re_mapping.setter
    def _original_tool_names_re_mapping(
        self,
        value: typing.Mapping[builtins.str, builtins.str],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6762bda91838241a6ee34d79cd8660a8ecf1de3ef553cabb0bd5130090bc15a3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "originalToolNamesReMapping", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="prompts")
    def prompts(self) -> typing.List[builtins.str]:
        '''- Prompts used by the agent.'''
        return typing.cast(typing.List[builtins.str], jsii.get(self, "prompts"))

    @prompts.setter
    def prompts(self, value: typing.List[builtins.str]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__da71d0425a1a175452f028e91eec348b008ccd07d2c4ee25c3bc20232edadfb3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "prompts", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="ready")
    def ready(self) -> builtins.bool:
        '''Indicates if the agent is ready and tools are loaded.'''
        return typing.cast(builtins.bool, jsii.get(self, "ready"))

    @ready.setter
    def ready(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__89bc6384ff613546183aa4186ddfac11deaaf2c2b3c4f43fd64f205dee4ad649)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "ready", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="sourceNodes")
    def source_nodes(self) -> typing.List[ISourceNode]:
        '''- Source nodes associated with the agent.'''
        return typing.cast(typing.List[ISourceNode], jsii.get(self, "sourceNodes"))

    @source_nodes.setter
    def source_nodes(self, value: typing.List[ISourceNode]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b1dff1fd2031b8c10437260cbaae7a1861611afa24cb0ca6b7126c825461d0aa)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "sourceNodes", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="status")
    def status(self) -> AgentStatus:
        '''- Current status of the agent.'''
        return typing.cast(AgentStatus, jsii.get(self, "status"))

    @status.setter
    def status(self, value: AgentStatus) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f657c5abb4af14138072346cc87aee77138c4171cd0fc2bf21f903fd6c6299ce)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "status", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="tools")
    def tools(self) -> typing.List[IAgentTool]:
        '''- Tools available to the agent.'''
        return typing.cast(typing.List[IAgentTool], jsii.get(self, "tools"))

    @tools.setter
    def tools(self, value: typing.List[IAgentTool]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d712115a2ab298e5d50d49c632fab67794a7409f1db441e663ee069fabba3ef8)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "tools", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="execution")
    def execution(self) -> typing.Optional[Execution]:
        return typing.cast(typing.Optional[Execution], jsii.get(self, "execution"))

    @execution.setter
    def execution(self, value: typing.Optional[Execution]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b67abdb1cba5becc669e94a301b7f98b7c0c0b097b682d08a910595e09541afb)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "execution", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="executionMemory")
    def execution_memory(self) -> typing.Optional[Memory]:
        return typing.cast(typing.Optional[Memory], jsii.get(self, "executionMemory"))

    @execution_memory.setter
    def execution_memory(self, value: typing.Optional[Memory]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__89fe0c3654814305defb5190865bb0e7e7946de0fcd8a1902cc070067eebac5a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "executionMemory", value) # pyright: ignore[reportArgumentType]

    @builtins.property
    @jsii.member(jsii_name="userDetails")
    def user_details(self) -> typing.Optional[IUserDetails]:
        return typing.cast(typing.Optional[IUserDetails], jsii.get(self, "userDetails"))

    @user_details.setter
    def user_details(self, value: typing.Optional[IUserDetails]) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0fabc29b53bc06a2b34ccc6428c40b29c90e1d5ec2e10f24d38c01e08691e82d)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "userDetails", value) # pyright: ignore[reportArgumentType]


__all__ = [
    "Agent",
    "AgentAccessScope",
    "AgentGraphItemSubType",
    "AgentGraphItemType",
    "AgentStatus",
    "Agents",
    "AmazonBedrockSupportedModels",
    "Base",
    "Configuration",
    "Execution",
    "ExecutionStatus",
    "FriendliAISupportedModels",
    "IAgentGraphItem",
    "IAgentGraphItemAdvancedFilteringOption",
    "IAgentGraphItemSchema",
    "IAgentGraphItemSettings",
    "IAgentInstructions",
    "IAgentTool",
    "IBedrockTool",
    "IBedrockToolOutput",
    "IBedrockToolSpec",
    "IBedrockToolSpecInputSchema",
    "IConfiguration",
    "IExecutionInput",
    "IGraphItem",
    "ILocalTool",
    "ILocalToolFunction",
    "IMemoryMessage",
    "INodeDescription",
    "INodeSchema",
    "IOpenAIToolFunctionOutput",
    "IOpenAIToolOutput",
    "IOperationNodeInstructions",
    "IPGSchema",
    "ISourceNode",
    "ITool",
    "IToolCall",
    "IToolCallPayload",
    "IToolExecutionResult",
    "IToolInstructions",
    "IToolParameter",
    "IUserDetails",
    "KnowledgeBase",
    "KnowledgeBaseStrategy",
    "LLMProvider",
    "Memory",
    "MemoryStrategy",
    "MemoryType",
    "NvidiaNIMSupportedModels",
    "OpenAISupportedModels",
    "RealTimeOpenAISupportedModels",
    "SourceNodeType",
    "ToolCall",
    "ToolCallResult",
    "ToolCallType",
    "XpanderClient",
]

publication.publish()

def _typecheckingstub__56c927c42c835c774c6f5f1f6f97fed3b3214baccc5c46df58f7f5cf97262992(
    configuration: Configuration,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb382a0499d6ff9252ba35bb8f4c90a05697129cfe9cad98a7f8a1a14da8e1d4(
    agent_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2f37932ab42616ef0215f3190c6c4bfa79237ec478d6c77803ea5cc9260af1f3(
    value: typing.List[Agent],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ec4b41eaf57993f4b49ed6bc9995e9ed9fa2685fb355f0d948717f7ea7e34c2f(
    value: Configuration,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0dab3da5f8c0475ccab1873969e148ad9dcbdb0ddf88c9ecc6b02b751238b6e5(
    data: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9d4d603584cc9880629c407e84565dc862d0614d798748f7556e51d6023943cb(
    data: typing.Mapping[typing.Any, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dafae5b4445df1b4c673783f144d770b151e831e63bc8be999b4708f966d5caa(
    __0: IConfiguration,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__135b56998170832cdd7296e91cdddd9c57d7b17d36e505bee4468b800785e5a3(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6025924c03e9981cc1b85f95320de6d369f9970a79f6ee17298111769cddfa5(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e66c1cb417d578246e8364e66bde633c4843b6604b43b28c0a1768e3d971c32a(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__20369269e83a8faf9b0e5c03d8b299c924f1479bf7cf5b8c1b3b9f8bb93c406f(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eb3511e5562e6adcbc92f800855d3a0afb25a625d0c55d5485a4a1dce9c4d0f5(
    id: builtins.str,
    agent_id: builtins.str,
    organization_id: builtins.str,
    input: IExecutionInput,
    status: ExecutionStatus,
    last_executed_node_id: typing.Optional[builtins.str] = None,
    memory_thread_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4cee0f42d8d8dd5f66e986850120e23b19cc68cac936f98a8dd25fb36353d17a(
    agent: Agent,
    execution_id: builtins.str,
    delta: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b03ca08f9b2b069041973b39cf02c9a0068d90548e5ddee63b20fe94c7012609(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6d868b6b5ce250193ce443b9016b04756769b83eeba535e78241ec0ff3f83d51(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fdf2cbec0d7a7f57322611349ee6da80c76ffc15d17073f0a02db00de934ea18(
    value: IExecutionInput,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__35f14ab38fd58bcb6df93f21afda177a617f7ba0d607127377b3613011486dd7(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71b5fe859564b314681ecc8ec189116efd662d6e84e6ac8185c34215670ec574(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__85cdb7bc0e59f92fdd53d0635a8fca37266c786acca82dac2cbfc332ac269981(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c6ea35b2f322e75bd9b6c5f06edfbe93b6c622ef9bc2c373933a362ffe4af250(
    value: ExecutionStatus,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5dba14c76a9e1d83ffe55a1c733b3576433fc58b9415d90dd9ac7028a869099b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d1310bff172f40782302ad59d15f277cb3c0918376af5cffdc3a5d030bd54da2(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__13bb03bb81a62ba75e0b9bcc5c88b4bd2b3bcf54337bbc16151c4259035cb477(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__534c594af7204b33827b73b3778e3d1536c5b4c3bf435df83ae64f63dab6e844(
    value: AgentGraphItemType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3a36cd909dd9399db70aeffbb9c356d023a3a896dbe5390dc5efe7c6414207b1(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5618f24c0659df546079898a6172773cf1b206836e9c323ea2d1a760d8c827b8(
    value: typing.Optional[IAgentGraphItemSettings],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__829f2208e58d3894303cd0b8b783a5a9e8634edee1b3a0b57974d04ac67611cc(
    value: typing.Optional[AgentGraphItemSubType],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c37442176fd38f417112ebe47d309cfbcd7730390b5e828c327831187383b0b9(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2a22b984d43570db7290f1372800735e3ac718279f0b81723ed1d35d12bc3e7f(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d83a27065ff688296f54a2b4a7b7bd9e2cf50799491f1783c29eecaa4fb598e3(
    value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__10c09b4778194db94a8d00c666b7a1871afdce4091cd3cac67e6f78ea507904a(
    value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82ddafee8c7509fd377d08cd4dcb4bd75f290d6cfee8836b9158c69a50a8d205(
    value: typing.Optional[typing.List[IAgentGraphItemAdvancedFilteringOption]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__48133c207df167a1e2ac7d22c1e6b7159bb3845cf34a55f28a9c340e4b17b5a0(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f5abe35889371107b0a28dc1777a7eed9117daefb0245778d0a219398b8b30de(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__60c048394bfb4cd680c4e606cd9f9da38990e641593522bda31ffc5307812b9f(
    value: typing.Optional[IAgentGraphItemSchema],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0a6ff80d5352340efac054e4b2567cc15950865e97d6cb43effd5e46955a1509(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__369b7570f3bb8d2e15f006de040b07d3b8bba3ff139b444614a52dad91982ca0(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0187dbb1b47ed4f762b69eaa81fd084a3a63cd5320cda1ccc47f169afaa2fdde(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__013ed94cf5075f5bf0c5bc74a0e8036501c284d35e4392ea6f15080eddc2a7ad(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b1b25237ddc5e6038acd2ee375459e97263388f5a79c9b19df1509b8ad33817e(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2ba86af1a111c4132196288035231114364f7fd5846ba31b895e28cf0263f6b0(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bdd4d28b7b8f38ee90640906c0dfa66779e13f1537479bfac62236199af53599(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bfb31aa04b21eb4806b8482aa225a11b478a08f9a3d8fe6ed1ff02f818c62244(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7629b10507753cd17f8a141e1f5acf42aa3ad6279b11466521e8e879158f1c0b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c1639f3cf0ce4876316784b66d4eb55d50082b87dcaa56347a0ebcb4c5be615(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76420473c4800542a5c924d1375223fda76771d1a194354c646c87a134351b2d(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__94d18303f76ca1cea7f0333afa6e171a5ff4c99c53601d4772e5d916b00ae6de(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__686bee2f9cc4cb8e5e46bd20309c912c48752fa01feec49d211288fe414d9879(
    value: IBedrockToolSpec,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__50442d45bad8e7fa927b6be3feac263e79712091c62056e831a391b5a17c13bc(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bab15f7ad29e9cbdf37869d4d12b1eca4937a0130eb1409bb74f1149d0dfc26b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__39dfbf6fa195f65cf55b428cbf9c7e700af738bcd9c47ebdda318cfedf78e70a(
    value: IBedrockToolSpecInputSchema,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0534d2b1daae9caffc87b99f4b6cc09e1a9eac3888374c04e9c619375c2f1b35(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1454322c6f1b39bdf36a5d88226526fce2d55d1e13ada58cf00d44f12fd64366(
    value: typing.Mapping[builtins.str, IToolParameter],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f3e8b15e3c3381cc6704c1ee29aa4c16d1b4a86e2ac011b6e441b3e0b431f930(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__07a526e81165d7b0acee70572029a007577d042379f52fcd7844f14a292ff14e(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__df183128da8ce312ade8f62d98d9db3bba128d9acf1d9f56955baae69e409c37(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1540b2d417df65eae973c655ee643690a0dcd51cb4e6c7e9d779c317f9cec97a(
    value: typing.Optional[builtins.bool],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__da3a818f4694a99ea585b769eb098754a7fe2d1868cc0704ace9d8e92ba7f3f1(
    value: IUserDetails,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ded72ddaf5f71f91ade05bb19c950ea501c6e1e1233100d5f19c597947e7d3aa(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8eb39d06928f51e090591017e234f9560633786e66b238d3b42531c3252f0eea(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__63dac3f67c0f52d800dcd097be9ddb6eb98f70c71ea8289dbaad0e94a58d47f1(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__53cbdb3cb6871f560d5a0a78bd2ceff7528297ba8da6e71aa3da216d1c0284f2(
    value: typing.Mapping[builtins.str, typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eaa5a9bfea7b1902145aadecc5674d2699888d69e501b26b8c8c3ad694675881(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__42a9c3fc5cff09316502fc55db2175287af1ef6831a515963059bd6de019711a(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__57c77329d9ea483c6111ccb444f6e30c3a08d7baf27c81a55cc015bb38ed9369(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6269099b38fe2e344fbcf8d67e4d22c04f53523963a6b49a82311bfff413a54b(
    value: typing.Optional[typing.List[IOperationNodeInstructions]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12e375f6294f1a5448700c974b2c29d93eaac36a1dea798ca8ded9b92594d10b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e2af096115236a1c0df0e3b558acc615c594ec3a2f016074ae50c4c83fcb2600(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__221c82f5a357c0f118efe86c29a8a97b2a8f51d955265c9972dc156543547bb0(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d263d1c0fb18bd7e903fe0d0af692e3808ac21c99197a495a3f6c62acba8a50b(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__25eaf42500bdb62a0efcb583df3587ae560b4f99f9d9214b8ebebc6131aec02e(
    value: typing.Optional[typing.List[IToolCall]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5029eec55150a99d387bd33a241844941678a723123f576ab5ca1dbe8560ac7f(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__64a691e85b135dcb7a3455055b40b75c9fd087eccfa1e4530a0d3b72f8779ae8(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__734c9db79aa3475cc0b924e42ac63aa8d52b10288609ab049f61de3218eb4e27(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f6782cb166f668691a7b4be7b743380ed50722ee1549291808eee66d6a811fed(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ebf5d7d569b37ac0c974cabb49c4e85f99273856f9fc2bdac40d66bc3412561d(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3b0db8ab6f32bead8676f5d65edb0c8465aea43ef940f7b1d7b2ba9d2d577c39(
    value: SourceNodeType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5f56ea2b548b4cdfe22f0f80bf2c3f88697c04aedd2bf7fe61755b4eb9cee55b(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5396ff1ffb06161e7b92840a35a663b1f418ffdcc7dde0e2593addf6ca31936a(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__682720a04a90eb0d29239c0baf8e36b53b239f76f1079edf9cd418a69ddb97ac(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0bf23d7676e5d1c7e307b10d99651d3e323b4741175a001eec3d04daa9f6a063(
    value: typing.Optional[typing.Mapping[builtins.str, IToolParameter]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5219f06879c23f3e080fc36ccd3ecf3404dfc6994def97d5e4ec94ce59d72bb7(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__039a35d67dfcf0e4fcf0d24c95fae7adcb68a33fbc193c12840c321781f41670(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4c4f34dbc98830433192bba8d2c699a1cb8148d1491b27977e6d346e261fb913(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c9832f75123fcf9d9b942f4c173edc15dd68204b28ad5d4260488d6c5c649f9e(
    value: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a367c116b987fb49136a9814177e4d056c61593dd022f63355bb894da7fc9988(
    value: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e21845a97036e31f029489182b71f645274dafcc99c56e102732ed75019f377(
    value: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__893f015e220df05bf7b08ec5d24e2064db840604744494f599f33b596f114ee0(
    value: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a45442afc737189c680b610029e36c0388f812ca6addfc20d90f2255236a7a1d(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f74a57170964ac6f2225d4a42e688907f1b3fc6d5dcc4cefae60ba4c69e6a205(
    value: typing.Mapping[builtins.str, typing.Any],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0f354465848d57d08212584493a7b8ebb70e6a4185a12514d09d39089267cc34(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd332b88cb4f7bb75ce8e88200df9b702232ca7807d466896031bba1bac55a15(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bbdc5a25cd119bc40de0970a3da5a996792b481e3623e5692f2220f66858eaff(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__116d46c0c30294630e565344bb001679a311f6d4bdf7fde9def35de5f5e69bff(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__09181db93f9b9267ab92d06c025f7bac4699c1fdac9ca798c651a63559aa913f(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__187dae4a63a6fee1ee6e1cb395b2f91742bd245c20c13ab04570590726c5ef61(
    value: typing.Mapping[builtins.str, IToolParameter],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__16039ce6185f742cd5865e412fc0342905a7a6d458331abeea0c8aea52fd0eb5(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__52b13164b7161ac045d14f7c4212e2fc304cf9b4c0234c2221c11807a860fee0(
    value: typing.Optional[typing.List[builtins.str]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__10f4d4aba0d7589de631b80acf65044a45841cfafe8c7f4fd9a1226e9f3be468(
    value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9fe6b035e53bc42a7e87bae4d7e9b65a2f04ef7a3d9e58cbe7b7a94d3e662c9c(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4ba223916284512961bbbf6e5b504fd43d4938ff7a56f95398d6624ef8b015e1(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ec5dcae8ec16cbd97f348dd46db610a14b3790249f32a3039c3b6acb9791d2e3(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__29613433172fd0f0dad44d9ee32b672116fbcf25f67f6f9a07db1b772585b2e8(
    value: typing.Optional[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__51e3a6f2086f6f694ae00811d3c8cfbc7998d5e84bc5e953097d209d2b1d9e8e(
    id: builtins.str,
    name: builtins.str,
    description: builtins.str,
    strategy: KnowledgeBaseStrategy,
    documents: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b5346ca86b97d9beb023662f6917773322c22dd333b4088d0a3e1aa3f9b863f1(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f91030cf0630f559d66490e3f6115e32fa737afa26a254c624598a4473424178(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2b1a6bd536d05cb8f737d34d1a5470e5cbffbae2b7b39eabd405ec3a83750f39(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ec5f1b09e3bf37c8db0a7e8a770f79ae3a608fbcf53ae579ab368ca80ea281b2(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c985cb1467f7bafe537bc1fe177d04bb3967730f168ac32ce862f8c3d39dbe95(
    value: KnowledgeBaseStrategy,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__81920271697ae42e098719be39b49bcd21415f983a883772a893c601ddaee6dd(
    agent: Agent,
    id: builtins.str,
    messages: typing.Sequence[IMemoryMessage],
    user_details: builtins.str,
    memory_type: MemoryType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__aac0cdf9d3941968c7d1fb460252d03479b6f845bc6ba305a0180fce4bcdb71b(
    agent: Agent,
    user_details: typing.Optional[IUserDetails] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5e2e59e4d3fb03b2220fd16d51c1c03d26c81217aecbc900c19d672d4777df78(
    agent: Agent,
    thread_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1a51857d33f65b0aeb1e47a32821416678e02e9977e28bcf191def00e1de1385(
    _messages: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__371bbac48ab4303b8878745ba398512a7e9b2282fcdf6e8b9dd183b48b03488e(
    tool_call_results: typing.Sequence[ToolCallResult],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0bdc7533e91a9993a0ae547e0986d3f0f7baf1f8fde5221f829e8393cd5e222f(
    input: IMemoryMessage,
    instructions: IAgentInstructions,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6ce51eb3bc0f66424dc100907e6b8645a78f014da089334b5683929638780555(
    instructions: IAgentInstructions,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c90de86ece903a3b93c8f19a918abf58c99227e7ca07b62b12149ae4d1d1f942(
    llm_provider: LLMProvider,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bbe18b88e2660e8696c14f8f8e6d7a160be4e10f351309c88ad1ef59993830d2(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__480c9de0d56a727b6080606ffa19389e9a950f96e37f7f9a97200fd43981ce7f(
    value: LLMProvider,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8b4f084a61d1e17795026fdf0d8050b34b2f09eea03d6dfbb5809384ca99e18c(
    value: MemoryType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__061b6a073f962d6437ad5fafa99b961231c85f17625aa93e208f2ab144777953(
    value: typing.List[IMemoryMessage],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e929e79b7b59a892685c04ee233be1c732bd06c519447292cd87e096540451a8(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c5b1512c48e4c0a4b618d417e46f7c83b02989356f2412aa0eae9d63b626ce0e(
    name: typing.Optional[builtins.str] = None,
    type: typing.Optional[ToolCallType] = None,
    payload: typing.Any = None,
    tool_call_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c7cce041752b4e95ae25466ea39d32f51ec0301e64015b66ccf20bb9b23db25e(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c1940e09fdc14592acfce7003f99bcc770eb4b17ea62e53e30d6cbfd4d3d3707(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__12d9b994824033489cb2b3b806044405bcb06c1d72048f017c89bb422b16b35e(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2059ec549c7384dd73be7be379faf6256c60a8ec7b55fdb9082692bbdc4bac54(
    value: ToolCallType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2debc725768136a46976eacab873877fdcc3efbb47c357e0973193213896e283(
    function_name: typing.Optional[builtins.str] = None,
    tool_call_id: typing.Optional[builtins.str] = None,
    payload: typing.Any = None,
    status_code: typing.Optional[jsii.Number] = None,
    result: typing.Any = None,
    is_success: typing.Optional[builtins.bool] = None,
    is_error: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3fffc9823e52bc6b5b2f4aa72f7ed94614aad7d55b77f29de8574547aa73f28f(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e12e85757c6557cdf77248e76a660df04102b8873b38236827fb882d1fa6439a(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e0ae8339ae925874f36d96caaf593a776e69a5def415e6cd597660d7e9c011e(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d2de087a3432f7b811bf4e98dd110380b61cb2d0cdcd014af55ea9c493c5e516(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8b512e8cc2e3d13362bf29e552b8dff26b147cd4cf7b3fc2ac09efd5bd6e5bd8(
    value: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2d7de4c43b1bcc39cb1dbd154a581a3c2a35f429555b50d12f81d0c6662c787a(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e548be6ee41a966ad4e21e38458b2dc18fde679b9017e65e4f088b5b0d8c3580(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2ada04f0df01e9b462e0b973aee5f69eda17ab0f22e7345f33423f0acca9ad36(
    api_key: builtins.str,
    base_url: typing.Any = None,
    with_metrics_report: typing.Optional[builtins.bool] = None,
    organization_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d89a5c88d1a2ed62ab765c38358d4adda81980f27657e34b4fe23fc61eca9217(
    llm_response: typing.Any,
    llm_provider: typing.Optional[LLMProvider] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__50de96ce44613a7f9044134d55c384c9cbc69918873535eed55a2d9c1f2cafbd(
    value: Agents,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0f24bf46a0a96d6e069bcfdce151aa22264da15a80125c376dbad457bf91d1c0(
    value: Configuration,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ed3ca6ba27cec860aa869deb2eaf5d80822747214c50652c074c1fd995c12295(
    configuration: Configuration,
    id: builtins.str,
    name: builtins.str,
    organization_id: builtins.str,
    status: AgentStatus,
    memory_type: MemoryType,
    memory_strategy: MemoryStrategy,
    instructions: IAgentInstructions,
    access_scope: AgentAccessScope,
    source_nodes: typing.Sequence[ISourceNode],
    prompts: typing.Sequence[builtins.str],
    tools: typing.Optional[typing.Sequence[IAgentTool]] = None,
    graph: typing.Optional[typing.Sequence[IAgentGraphItem]] = None,
    knowledge_bases: typing.Optional[typing.Sequence[KnowledgeBase]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b1a4e9d238bcd6575542fe126282fe717dabbed97bd4b5d5f0906439f6debd49(
    tools: typing.Union[typing.Sequence[typing.Any], typing.Sequence[ILocalTool]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__773e3afa26f8b79fe00973c69c9983fbf523bfd2f52c02c0a473df8878934452(
    llm_provider: typing.Optional[LLMProvider] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__16872029ef2ca9a4aea1671c278ba6987a5be977e7311f29693d64313ecee69b(
    execution: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b76974a0e120e8cf7b77d0deb9b609235bfbb31f7bb65ad41e928422ab50a6b3(
    item_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0e1ca0e533f7a6dc6cf8465ad7809ba4a450abee064ca45429a80a258a5e2e65(
    tool: ToolCall,
    payload_extension: typing.Any = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__307c287f13e8189f59310f2e5a43f33ebb271c35e1502a531966c06bbe13ef32(
    tool_calls: typing.Sequence[ToolCall],
    payload_extension: typing.Any = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__83adb98120d61cd6e5328f2ce8718542d01899c0e61b507458cf4b016b21ae58(
    user_details: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bcb6c11034237fb99d4afc18d0b8280c1e1f09ddaefe3eb074cf796e3b725e93(
    value: AgentAccessScope,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2acddc917b6b415bc14dfb9a7094cbd1b0319e93c3c4b3298f8cb5d9ec8206a7(
    value: Configuration,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__455c760f94e4fc5ed8c239f2c501ce6bf2eb3da9a89e20e6afdd569a617b8ab0(
    value: typing.List[IAgentGraphItem],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e0b9d8c488cea43db21adbef0723558d2e632d07b3f9134efdeb872de791fa1d(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__729aa75df9167864d69d977ed37c2a63fa4c55e59a6a6595769ebe73e9503771(
    value: IAgentInstructions,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d560d33d3a8d9ab2d5d84adacd04b2b8a4d5a0db676c32684e81f32478d93eaa(
    value: typing.List[KnowledgeBase],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cdc78718c4e88ad0687034fec3393a9b0dd4518c626fe4c60d2244cefaadbe37(
    value: typing.List[ILocalTool],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f78a447686d7a170f7713415428aefc1544249c3da73e354d5f28a8917f689ae(
    value: MemoryStrategy,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__805f0dbb3034522e5cd382a8d7f7c31a544db0bd26e45b0915f5b060aec59bed(
    value: MemoryType,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__22da1a47b30804817cea4f52e46761946f71d0d3436d3236d8ab8bbd3f9a2364(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4b78331aeaf11efbf7d44a1bd4ce9783ac8b3be074090b3f146520a09bb2ff99(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6762bda91838241a6ee34d79cd8660a8ecf1de3ef553cabb0bd5130090bc15a3(
    value: typing.Mapping[builtins.str, builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__da71d0425a1a175452f028e91eec348b008ccd07d2c4ee25c3bc20232edadfb3(
    value: typing.List[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__89bc6384ff613546183aa4186ddfac11deaaf2c2b3c4f43fd64f205dee4ad649(
    value: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b1dff1fd2031b8c10437260cbaae7a1861611afa24cb0ca6b7126c825461d0aa(
    value: typing.List[ISourceNode],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f657c5abb4af14138072346cc87aee77138c4171cd0fc2bf21f903fd6c6299ce(
    value: AgentStatus,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d712115a2ab298e5d50d49c632fab67794a7409f1db441e663ee069fabba3ef8(
    value: typing.List[IAgentTool],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b67abdb1cba5becc669e94a301b7f98b7c0c0b097b682d08a910595e09541afb(
    value: typing.Optional[Execution],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__89fe0c3654814305defb5190865bb0e7e7946de0fcd8a1902cc070067eebac5a(
    value: typing.Optional[Memory],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0fabc29b53bc06a2b34ccc6428c40b29c90e1d5ec2e10f24d38c01e08691e82d(
    value: typing.Optional[IUserDetails],
) -> None:
    """Type checking stubs"""
    pass
