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"
    LOCAL_TOOL = "LOCAL_TOOL"


@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"


@jsii.enum(jsii_type="xpander-sdk.AgentType")
class AgentType(enum.Enum):
    REGULAR = "REGULAR"
    MANAGER = "MANAGER"


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="create")
    def create(
        self,
        name: builtins.str,
        type: typing.Optional[AgentType] = None,
    ) -> "Agent":
        '''
        :param name: - The name of the agent to be created.
        :param type: - The type of the agent, defaults to Regular.

        :return: The created agent's details.

        :description: Creates a new agent with the given name and type.
        :function: create
        :memberof: xpanderAI
        :throws: {Error} If the creation process fails.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76702171336bf6b0ea472737a1f7d3c35de102f261244c52f4175ac7a6799b14)
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        return typing.cast("Agent", jsii.invoke(self, "create", [name, type]))

    @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 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,
        parent_execution: typing.Optional[builtins.str] = None,
        worker_id: typing.Optional[builtins.str] = None,
        result: typing.Optional[builtins.str] = None,
        llm_tokens: typing.Optional["Tokens"] = 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.
        :param parent_execution: -
        :param worker_id: - Identifier of the worker associated with the execution.
        :param result: -
        :param llm_tokens: -
        '''
        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"])
            check_type(argname="argument parent_execution", value=parent_execution, expected_type=type_hints["parent_execution"])
            check_type(argname="argument worker_id", value=worker_id, expected_type=type_hints["worker_id"])
            check_type(argname="argument result", value=result, expected_type=type_hints["result"])
            check_type(argname="argument llm_tokens", value=llm_tokens, expected_type=type_hints["llm_tokens"])
        jsii.create(self.__class__, self, [id, agent_id, organization_id, input, status, last_executed_node_id, memory_thread_id, parent_execution, worker_id, result, llm_tokens])

    @jsii.member(jsii_name="create")
    @builtins.classmethod
    def create(
        cls,
        agent: "Agent",
        input: builtins.str,
        files: typing.Sequence[builtins.str],
        worker_id: typing.Optional[builtins.str] = None,
        thread_id: typing.Optional[builtins.str] = None,
    ) -> typing.Any:
        '''
        :param agent: -
        :param input: -
        :param files: -
        :param worker_id: -
        :param thread_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28ac71fcc66c47d57a2431d7b9d1ededfeebe4d25d4d76be0af7aea52433b43e)
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
            check_type(argname="argument files", value=files, expected_type=type_hints["files"])
            check_type(argname="argument worker_id", value=worker_id, expected_type=type_hints["worker_id"])
            check_type(argname="argument thread_id", value=thread_id, expected_type=type_hints["thread_id"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "create", [agent, input, files, worker_id, thread_id]))

    @jsii.member(jsii_name="fetch")
    @builtins.classmethod
    def fetch(cls, agent: "Agent", execution_id: builtins.str) -> typing.Any:
        '''
        :param agent: -
        :param execution_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5826ee4343bbc6d6fa82b8318fb69ba8915209dc65ef5871fcded50883e01a3b)
            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"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "fetch", [agent, execution_id]))

    @jsii.member(jsii_name="initExecution")
    @builtins.classmethod
    def init_execution(cls, created_execution: typing.Any) -> "Execution":
        '''
        :param created_execution: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1a16dd673599a3466cd88daa634558ce551e5bf88775633c2a1b347c8d331cc4)
            check_type(argname="argument created_execution", value=created_execution, expected_type=type_hints["created_execution"])
        return typing.cast("Execution", jsii.sinvoke(cls, "initExecution", [created_execution]))

    @jsii.member(jsii_name="retrievePendingExecution")
    @builtins.classmethod
    def retrieve_pending_execution(
        cls,
        agent: "Agent",
        worker_id: builtins.str,
    ) -> typing.Any:
        '''
        :param agent: -
        :param worker_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__77c3a6862ed0afbaef96d1fb83314e009abc247417477fc19054c75929da550d)
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
            check_type(argname="argument worker_id", value=worker_id, expected_type=type_hints["worker_id"])
        return typing.cast(typing.Any, jsii.sinvoke(cls, "retrievePendingExecution", [agent, worker_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="llmTokens")
    def llm_tokens(self) -> "Tokens":
        return typing.cast("Tokens", jsii.get(self, "llmTokens"))

    @llm_tokens.setter
    def llm_tokens(self, value: "Tokens") -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2b8ec1c80577669cd65855b4bfcc994db091cf6f987b85815778246c461c834f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "llmTokens", 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="parentExecution")
    def parent_execution(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "parentExecution"))

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

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

    @result.setter
    def result(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cba55b034120440ccd908317158f72c44d2b7322aebe344934e7495df875f5bb)
            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="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]

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

    @worker_id.setter
    def worker_id(self, value: builtins.str) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b54b957eb2ffee3bc5db4dc5843d7381ada868fa8b19457c6ae7bb85e5235834)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "workerId", 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 Graph(Base, metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.Graph"):
    '''Represents a graph structure containing nodes related to an agent.

    :class: Graph
    :extends: Base *
    :memberof: xpander.ai
    '''

    def __init__(self, agent: "Agent", items: typing.Sequence["GraphItem"]) -> None:
        '''
        :param agent: -
        :param items: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__05c62bde7fdbe61c5e8a021bd34dd2caa05004f9b05f08679285c1916bbac5c0)
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
            check_type(argname="argument items", value=items, expected_type=type_hints["items"])
        jsii.create(self.__class__, self, [agent, items])

    @jsii.member(jsii_name="addNode")
    def add_node(self, node: typing.Union["GraphItem", "Agent"]) -> "GraphItem":
        '''Adds a new node to the graph.

        :param node: - The node to add, which can be an agent or a graph item.

        :return: The newly added graph item.

        :throws: {Error} If adding the node fails.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fa425681e3f5e5317e5e11364c4e8fd5e072b73205f40342eb460fdc7c769fa5)
            check_type(argname="argument node", value=node, expected_type=type_hints["node"])
        return typing.cast("GraphItem", jsii.invoke(self, "addNode", [node]))

    @jsii.member(jsii_name="findNodeByItemId")
    def find_node_by_item_id(
        self,
        item_id: builtins.str,
    ) -> typing.Optional["GraphItem"]:
        '''Finds a node in the graph by its item ID.

        :param item_id: - The item ID to search for.

        :return: The found graph item or undefined if not found.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4b1d141f90de09eccb807109ef6536ff2c9788996c910b07bd8d1e73db2d04a6)
            check_type(argname="argument item_id", value=item_id, expected_type=type_hints["item_id"])
        return typing.cast(typing.Optional["GraphItem"], jsii.invoke(self, "findNodeByItemId", [item_id]))

    @jsii.member(jsii_name="findNodeByNodeId")
    def find_node_by_node_id(
        self,
        node_id: builtins.str,
    ) -> typing.Optional["GraphItem"]:
        '''Finds a node in the graph by its node ID.

        :param node_id: - The node ID to search for.

        :return: The found graph item or undefined if not found.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9e5c908c03ffa1a741480d3abd5a079bcf0c1ac187699aed7deb5ab56fce6529)
            check_type(argname="argument node_id", value=node_id, expected_type=type_hints["node_id"])
        return typing.cast(typing.Optional["GraphItem"], jsii.invoke(self, "findNodeByNodeId", [node_id]))

    @jsii.member(jsii_name="reset")
    def reset(self) -> None:
        '''Resets the graph for the associated agent.

        :throws: {Error} If resetting the graph fails.
        '''
        return typing.cast(None, jsii.invoke(self, "reset", []))

    @builtins.property
    @jsii.member(jsii_name="isEmpty")
    def is_empty(self) -> builtins.bool:
        '''Checks whether the graph is empty.

        :return: True if the graph is empty, false otherwise.
        '''
        return typing.cast(builtins.bool, jsii.get(self, "isEmpty"))

    @builtins.property
    @jsii.member(jsii_name="nodes")
    def nodes(self) -> typing.List["GraphItem"]:
        '''Gets the list of nodes in the graph.

        :return: The list of graph items.
        '''
        return typing.cast(typing.List["GraphItem"], jsii.get(self, "nodes"))

    @builtins.property
    @jsii.member(jsii_name="lastNode")
    def last_node(self) -> typing.Optional["GraphItem"]:
        '''Gets the last node in the graph.

        :return: The last graph item or undefined if the graph is empty.
        '''
        return typing.cast(typing.Optional["GraphItem"], jsii.get(self, "lastNode"))


class GraphItem(Base, metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.GraphItem"):
    '''Represents a single item (node) in an agent's graph structure.

    :class: GraphItem
    :extends: Base *
    :memberof: xpander.ai
    '''

    def __init__(
        self,
        agent: "Agent",
        id: typing.Optional[builtins.str] = None,
        item_id: typing.Optional[builtins.str] = None,
        name: typing.Optional[builtins.str] = None,
        type: typing.Optional[AgentGraphItemType] = None,
        is_local_tool: typing.Optional[builtins.bool] = None,
        targets: typing.Optional[typing.Sequence[builtins.str]] = None,
        settings: typing.Optional["IAgentGraphItemSettings"] = None,
    ) -> None:
        '''
        :param agent: -
        :param id: -
        :param item_id: -
        :param name: -
        :param type: -
        :param is_local_tool: -
        :param targets: -
        :param settings: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__15160dba22952263e9151beef520c9612beb9cb07eed594d7bb4d56d5119adb4)
            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 item_id", value=item_id, expected_type=type_hints["item_id"])
            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 is_local_tool", value=is_local_tool, expected_type=type_hints["is_local_tool"])
            check_type(argname="argument targets", value=targets, expected_type=type_hints["targets"])
            check_type(argname="argument settings", value=settings, expected_type=type_hints["settings"])
        jsii.create(self.__class__, self, [agent, id, item_id, name, type, is_local_tool, targets, settings])

    @jsii.member(jsii_name="connect")
    def connect(self, targets: typing.Sequence["GraphItem"]) -> "GraphItem":
        '''Connects this graph item to other graph items, creating edges in the graph.

        :param targets: - The target graph items to connect to.

        :return: The updated graph item after establishing connections.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f56ab7aacb7878e1d39e5898ac1427926bfc05426f15db694d3fc0ff734dedad)
            check_type(argname="argument targets", value=targets, expected_type=type_hints["targets"])
        return typing.cast("GraphItem", jsii.invoke(self, "connect", [targets]))

    @jsii.member(jsii_name="save")
    def save(self) -> "GraphItem":
        '''Saves the current graph item state to the server.

        :return: The updated graph item after saving.

        :throws: {Error} If saving the graph item fails.
        '''
        return typing.cast("GraphItem", jsii.invoke(self, "save", []))

    @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__74968991c9a0c8c387a3fd1115e9e2ee1dcfc781eafd41ea456f2215d517ff05)
            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="isLocalTool")
    def is_local_tool(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "isLocalTool"))

    @is_local_tool.setter
    def is_local_tool(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ad4d6791c897c3b4cba72154de942bf44559197ad1162bd5610ffe8e1672b11f)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "isLocalTool", 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__ebba065518cc99903325a7584e1d0747cc5bcfea4a9cd32a741ae37d3f91b2f7)
            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="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__c3a4981d71edb62a9f18e2559a8e1c3ce4c8234ae77ce043029575f4d94187c2)
            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="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__ac535ec8b6e6592e8b1da2efcbcc433463a94dc3f8b822fc0ffbae7245e36820)
            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__3fefc2e34cc9c85d0ecc86ca114ee5d300ccf9e14fe00bb70821a4796b530eb6)
            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="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__66d78e4b33ae25244cb7b81ee8ec05b2cc6797c8ff01f37b427240985f25f7c3)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "settings", value) # pyright: ignore[reportArgumentType]


@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])

    @jsii.member(jsii_name="loadByAgent")
    @builtins.classmethod
    def load_by_agent(cls, agent: "Agent") -> typing.List["KnowledgeBase"]:
        '''
        :param agent: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9fd9e1109152304880a099fddab37e97bb8a4b8eac7d4eaeb9ba5b64b7d20f6c)
            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
        return typing.cast(typing.List["KnowledgeBase"], jsii.sinvoke(cls, "loadByAgent", [agent]))

    @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 LLMTokens(metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.LLMTokens"):
    def __init__(
        self,
        completion_tokens: typing.Optional[jsii.Number] = None,
        prompt_tokens: typing.Optional[jsii.Number] = None,
        total_tokens: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param completion_tokens: -
        :param prompt_tokens: -
        :param total_tokens: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0e1b070d38acba21af9e85835b7f9505be50edca1af2b7ad290db29d26ba43e1)
            check_type(argname="argument completion_tokens", value=completion_tokens, expected_type=type_hints["completion_tokens"])
            check_type(argname="argument prompt_tokens", value=prompt_tokens, expected_type=type_hints["prompt_tokens"])
            check_type(argname="argument total_tokens", value=total_tokens, expected_type=type_hints["total_tokens"])
        jsii.create(self.__class__, self, [completion_tokens, prompt_tokens, total_tokens])

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

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

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

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

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

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


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="addKnowledgeBase")
    def add_knowledge_base(self) -> None:
        return typing.cast(None, jsii.invoke(self, "addKnowledgeBase", []))

    @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="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="initMessages")
    def init_messages(
        self,
        input: IMemoryMessage,
        instructions: IAgentInstructions,
        llm_provider: typing.Optional[LLMProvider] = None,
    ) -> None:
        '''Initializes the thread with input and instructions.

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

    @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", []))

    @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"


@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 Tokens(metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.Tokens"):
    def __init__(
        self,
        inner: typing.Optional[LLMTokens] = None,
        worker: typing.Optional[LLMTokens] = None,
    ) -> None:
        '''
        :param inner: -
        :param worker: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dd35ef6de1c9651bc7d151f4efc8c1f0db15088148591bc019d5cea3dd7a8bc2)
            check_type(argname="argument inner", value=inner, expected_type=type_hints["inner"])
            check_type(argname="argument worker", value=worker, expected_type=type_hints["worker"])
        jsii.create(self.__class__, self, [inner, worker])

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

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

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

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


class ToolCall(Base, metaclass=jsii.JSIIMeta, jsii_type="xpander-sdk.ToolCall"):
    '''Represents a tool call with its metadata and payload.

    :class: ToolCall
    :extends: Base *
    :memberof: xpander.ai
    '''

    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,
        graph_approved: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param name: -
        :param type: -
        :param payload: -
        :param tool_call_id: -
        :param graph_approved: -
        '''
        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"])
            check_type(argname="argument graph_approved", value=graph_approved, expected_type=type_hints["graph_approved"])
        jsii.create(self.__class__, self, [name, type, payload, tool_call_id, graph_approved])

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

    @graph_approved.setter
    def graph_approved(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6fa618f493b9f124cef109e56d0f709f1b78016dbeb7ed55a9eb8cdc733dba99)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "graphApproved", 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__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",
):
    '''Represents the result of a tool call execution.

    :class: ToolCallResult
    :extends: Base *
    :memberof: xpander.ai
    '''

    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,
        graph_approved: 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: -
        :param graph_approved: -
        '''
        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"])
            check_type(argname="argument graph_approved", value=graph_approved, expected_type=type_hints["graph_approved"])
        jsii.create(self.__class__, self, [function_name, tool_call_id, payload, status_code, result, is_success, is_error, graph_approved])

    @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="graphApproved")
    def graph_approved(self) -> builtins.bool:
        return typing.cast(builtins.bool, jsii.get(self, "graphApproved"))

    @graph_approved.setter
    def graph_approved(self, value: builtins.bool) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1d03c735e160319bb8f7ff2043b62a07dc4ac091a1eb43c315b5be4128fcf92a)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "graphApproved", 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]))

    @jsii.member(jsii_name="retrievePendingLocalToolCalls")
    @builtins.classmethod
    def retrieve_pending_local_tool_calls(
        cls,
        tool_calls: typing.Sequence[ToolCall],
    ) -> typing.List[ToolCall]:
        '''Filters and retrieves local tool calls from a given list of tool calls.

        :param tool_calls: - The list of tool calls to filter.

        :return: An array of tool calls that are of type LOCAL.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f435d83beaf0c0d7ba5fac4b14d448f0cd185e5af1d9aff81d5cfc4147374b61)
            check_type(argname="argument tool_calls", value=tool_calls, expected_type=type_hints["tool_calls"])
        return typing.cast(typing.List[ToolCall], jsii.sinvoke(cls, "retrievePendingLocalToolCalls", [tool_calls]))

    @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[typing.Any]] = 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: -
        :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="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__28c763e76e4ecb7f7a77fe6c2dba333b644ea0abddac2e6c51dcad464709b85e)
            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="addTask")
    def add_task(
        self,
        input: typing.Optional[builtins.str] = None,
        files: typing.Optional[typing.Sequence[builtins.str]] = None,
        use_worker: typing.Optional[builtins.bool] = None,
        thread_id: typing.Optional[builtins.str] = None,
    ) -> Execution:
        '''
        :param input: -
        :param files: -
        :param use_worker: -
        :param thread_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7d16546c5c195ddef4391e46da78707938e8cd6d85040e33d40bc00a7120446e)
            check_type(argname="argument input", value=input, expected_type=type_hints["input"])
            check_type(argname="argument files", value=files, expected_type=type_hints["files"])
            check_type(argname="argument use_worker", value=use_worker, expected_type=type_hints["use_worker"])
            check_type(argname="argument thread_id", value=thread_id, expected_type=type_hints["thread_id"])
        return typing.cast(Execution, jsii.invoke(self, "addTask", [input, files, use_worker, thread_id]))

    @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__e9b6b5a079da787d90c8d00f39c55c743d24f5ed3b67480566451861a7cd9ec9)
            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="attachOperations")
    def attach_operations(
        self,
        operations: typing.Sequence["AgenticOperation"],
    ) -> None:
        '''Attaches a list of agentic operations to the agent.

        :param operations: - The list of agentic operations to attach.

        :memberof: xpander.ai
        :throws: {Error} If the attachment process fails.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__714c96a4dcb9157921296811cd8edcf9f84bf337706dac7c155320ff730bcbf2)
            check_type(argname="argument operations", value=operations, expected_type=type_hints["operations"])
        return typing.cast(None, jsii.invoke(self, "attachOperations", [operations]))

    @jsii.member(jsii_name="disableAgentEndTool")
    def disable_agent_end_tool(self) -> None:
        return typing.cast(None, jsii.invoke(self, "disableAgentEndTool", []))

    @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, agent_id: typing.Optional[builtins.str] = None) -> None:
        '''Loads the agent data from its source node type.

        :param agent_id: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__083e27f1b35697c0dc5dd7bec052ea93d4a2fd3d2ee05d66ed6dfd7754537ddb)
            check_type(argname="argument agent_id", value=agent_id, expected_type=type_hints["agent_id"])
        return typing.cast(None, jsii.invoke(self, "load", [agent_id]))

    @jsii.member(jsii_name="retrieveAgenticInterfaces")
    def retrieve_agentic_interfaces(
        self,
        ignore_cache: typing.Optional[builtins.bool] = None,
    ) -> typing.List["AgenticInterface"]:
        '''Retrieves a list of available agentic interfaces.

        :param ignore_cache: - Whether to ignore cached data and fetch fresh data.

        :return: A list of agentic interfaces.

        :memberof: xpander.ai
        :throws: {Error} If retrieval fails.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0958d9b6b5bfc800ebaa305539fc9dcd3ddf83cfd3fd110883c1698d297f6349)
            check_type(argname="argument ignore_cache", value=ignore_cache, expected_type=type_hints["ignore_cache"])
        return typing.cast(typing.List["AgenticInterface"], jsii.invoke(self, "retrieveAgenticInterfaces", [ignore_cache]))

    @jsii.member(jsii_name="retrieveAgenticOperations")
    def retrieve_agentic_operations(
        self,
        agentic_interface: "AgenticInterface",
        ignore_cache: typing.Optional[builtins.bool] = None,
    ) -> typing.List["AgenticOperation"]:
        '''Retrieves a list of operations for a given agentic interface.

        :param agentic_interface: - The agentic interface to retrieve operations for.
        :param ignore_cache: - Whether to ignore cached data and fetch fresh data.

        :return: A list of agentic operations.

        :memberof: xpander.ai
        :throws: {Error} If retrieval fails.
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2b9086ebd87942a70c9515c8974e8d9cab5772e11bb9fcb24a227d204d9923f9)
            check_type(argname="argument agentic_interface", value=agentic_interface, expected_type=type_hints["agentic_interface"])
            check_type(argname="argument ignore_cache", value=ignore_cache, expected_type=type_hints["ignore_cache"])
        return typing.cast(typing.List["AgenticOperation"], jsii.invoke(self, "retrieveAgenticOperations", [agentic_interface, ignore_cache]))

    @jsii.member(jsii_name="retrieveExecutionResult")
    def retrieve_execution_result(self) -> Execution:
        return typing.cast(Execution, jsii.invoke(self, "retrieveExecutionResult", []))

    @jsii.member(jsii_name="retrieveNodeFromGraph")
    def retrieve_node_from_graph(
        self,
        item_id: builtins.str,
    ) -> typing.Optional[GraphItem]:
        '''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[GraphItem], jsii.invoke(self, "retrieveNodeFromGraph", [item_id]))

    @jsii.member(jsii_name="runTool")
    def run_tool(
        self,
        tool: ToolCall,
        payload_extension: typing.Any = None,
        is_multiple: typing.Optional[builtins.bool] = 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.
        :param is_multiple: -

        :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"])
            check_type(argname="argument is_multiple", value=is_multiple, expected_type=type_hints["is_multiple"])
        return typing.cast(ToolCallResult, jsii.invoke(self, "runTool", [tool, payload_extension, is_multiple]))

    @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="stop")
    def stop(self) -> None:
        return typing.cast(None, jsii.invoke(self, "stop", []))

    @jsii.member(jsii_name="sync")
    def sync(self) -> "Agent":
        '''
        :return: The deployed agent's details.

        :description: Syncs and deploys the agent along with its related assets.
        :function: sync
        :memberof: xpanderAI
        :throws: {Error} If the sync process fails.
        '''
        return typing.cast("Agent", jsii.invoke(self, "sync", []))

    @jsii.member(jsii_name="update")
    def update(self) -> "Agent":
        '''
        :return: The updated agent's details.

        :description: Updates the agent with the current instance's properties.
        :function: update
        :memberof: xpanderAI
        :throws: {Error} If the update process fails.
        '''
        return typing.cast("Agent", jsii.invoke(self, "update", []))

    @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="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="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="messages")
    def messages(self) -> typing.List[typing.Any]:
        '''Retrieves list of messages.

        :return: A list of messages according to the agent's llm provider.
        '''
        return typing.cast(typing.List[typing.Any], jsii.get(self, "messages"))

    @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="toolChoice")
    def tool_choice(self) -> builtins.str:
        '''Gets the tool choice mode.

        :return: Returns 'required' if ``withAgentEndTool`` is true, otherwise 'auto'.
        '''
        return typing.cast(builtins.str, jsii.get(self, "toolChoice"))

    @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="vanillaKnowledgeBases")
    def vanilla_knowledge_bases(self) -> typing.List[KnowledgeBase]:
        '''Retrieves the vanilla knowledge bases of the agent.'''
        return typing.cast(typing.List[KnowledgeBase], jsii.get(self, "vanillaKnowledgeBases"))

    @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) -> Graph:
        return typing.cast(Graph, jsii.get(self, "graph"))

    @graph.setter
    def graph(self, value: Graph) -> 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]


class AgenticInterface(
    Base,
    metaclass=jsii.JSIIMeta,
    jsii_type="xpander-sdk.AgenticInterface",
):
    '''Represents an agentic interface with identifying and descriptive properties.

    :class: AgenticInterface
    :extends: Base *
    :memberof: xpander.ai
    '''

    def __init__(
        self,
        id: builtins.str,
        name: builtins.str,
        summary: builtins.str,
        description: builtins.str,
    ) -> None:
        '''
        :param id: -
        :param name: -
        :param summary: -
        :param description: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d0421198e44ee66874d3a9ac56a6a99b6dc0f7eaeda89671242d6bf39f995ebb)
            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 summary", value=summary, expected_type=type_hints["summary"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
        jsii.create(self.__class__, self, [id, name, summary, description])

    @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__56a0933f379e823c8bd5a098d8cd0823f5da788f81e2cf82493bf3af19aa8278)
            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="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__08bd8a9295a3f6bca09f1c529729d2e5992f248ccf768c476242ab5d1de6783b)
            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__31c02741e670a81628ccc3d3192b3361264d004315b890e135943817d1d096be)
            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="summary")
    def summary(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "summary"))

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


class AgenticOperation(
    Base,
    metaclass=jsii.JSIIMeta,
    jsii_type="xpander-sdk.AgenticOperation",
):
    '''Represents an agentic operation with metadata and execution details.

    :class: AgenticOperation
    :extends: Base *
    :memberof: xpander.ai
    '''

    def __init__(
        self,
        id: builtins.str,
        name: builtins.str,
        summary: builtins.str,
        description: builtins.str,
        id_to_use_on_graph: builtins.str,
        interface_id: builtins.str,
        is_function: builtins.bool,
        method: builtins.str,
        path: builtins.str,
    ) -> None:
        '''
        :param id: -
        :param name: -
        :param summary: -
        :param description: -
        :param id_to_use_on_graph: -
        :param interface_id: -
        :param is_function: -
        :param method: -
        :param path: -
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d00f579f8b6ee8853d6931c865ecc5f5725966e5904e8b93d829aa1ee31f452c)
            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 summary", value=summary, expected_type=type_hints["summary"])
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument id_to_use_on_graph", value=id_to_use_on_graph, expected_type=type_hints["id_to_use_on_graph"])
            check_type(argname="argument interface_id", value=interface_id, expected_type=type_hints["interface_id"])
            check_type(argname="argument is_function", value=is_function, expected_type=type_hints["is_function"])
            check_type(argname="argument method", value=method, expected_type=type_hints["method"])
            check_type(argname="argument path", value=path, expected_type=type_hints["path"])
        jsii.create(self.__class__, self, [id, name, summary, description, id_to_use_on_graph, interface_id, is_function, method, path])

    @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__16136fd2cfb48534b715b821da91ba0ebd50f4bc91c89635be6fd883c37e98c7)
            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="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__3a0c69767cc9b4f79e6e93e447d7eefbd6f542b65f5bf0159dc4a2903ae01ac8)
            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="idToUseOnGraph")
    def id_to_use_on_graph(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "idToUseOnGraph"))

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

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

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

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

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

    @builtins.property
    @jsii.member(jsii_name="method")
    def method(self) -> builtins.str:
        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__8bea3b9c44e7fc9bb175da70e7039e2646073c61c4a79c867792dc37e52e95eb)
            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:
        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__307dd21d55d2a3ba195730e39e0dc6189176bbd4eb3c27a4189933af67a0550e)
            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="path")
    def path(self) -> builtins.str:
        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__346d4f6c174a3dd581dd1a41074b805bf9d98571e4c31a3bee2fa180205bc608)
            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="summary")
    def summary(self) -> builtins.str:
        return typing.cast(builtins.str, jsii.get(self, "summary"))

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


__all__ = [
    "Agent",
    "AgentAccessScope",
    "AgentGraphItemSubType",
    "AgentGraphItemType",
    "AgentStatus",
    "AgentType",
    "AgenticInterface",
    "AgenticOperation",
    "Agents",
    "Base",
    "Configuration",
    "Execution",
    "ExecutionStatus",
    "Graph",
    "GraphItem",
    "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",
    "LLMTokens",
    "Memory",
    "MemoryStrategy",
    "MemoryType",
    "SourceNodeType",
    "Tokens",
    "ToolCall",
    "ToolCallResult",
    "ToolCallType",
    "XpanderClient",
]

publication.publish()

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

def _typecheckingstub__76702171336bf6b0ea472737a1f7d3c35de102f261244c52f4175ac7a6799b14(
    name: builtins.str,
    type: typing.Optional[AgentType] = None,
) -> 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,
    parent_execution: typing.Optional[builtins.str] = None,
    worker_id: typing.Optional[builtins.str] = None,
    result: typing.Optional[builtins.str] = None,
    llm_tokens: typing.Optional[Tokens] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28ac71fcc66c47d57a2431d7b9d1ededfeebe4d25d4d76be0af7aea52433b43e(
    agent: Agent,
    input: builtins.str,
    files: typing.Sequence[builtins.str],
    worker_id: typing.Optional[builtins.str] = None,
    thread_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5826ee4343bbc6d6fa82b8318fb69ba8915209dc65ef5871fcded50883e01a3b(
    agent: Agent,
    execution_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__77c3a6862ed0afbaef96d1fb83314e009abc247417477fc19054c75929da550d(
    agent: Agent,
    worker_id: builtins.str,
) -> 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__2b8ec1c80577669cd65855b4bfcc994db091cf6f987b85815778246c461c834f(
    value: Tokens,
) -> 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__98eb70fdda04bc040f99a78963bf4c39b92357daed49526791876d5d160ac033(
    value: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

def _typecheckingstub__05c62bde7fdbe61c5e8a021bd34dd2caa05004f9b05f08679285c1916bbac5c0(
    agent: Agent,
    items: typing.Sequence[GraphItem],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fa425681e3f5e5317e5e11364c4e8fd5e072b73205f40342eb460fdc7c769fa5(
    node: typing.Union[GraphItem, Agent],
) -> None:
    """Type checking stubs"""
    pass

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

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

def _typecheckingstub__15160dba22952263e9151beef520c9612beb9cb07eed594d7bb4d56d5119adb4(
    agent: Agent,
    id: typing.Optional[builtins.str] = None,
    item_id: typing.Optional[builtins.str] = None,
    name: typing.Optional[builtins.str] = None,
    type: typing.Optional[AgentGraphItemType] = None,
    is_local_tool: typing.Optional[builtins.bool] = None,
    targets: typing.Optional[typing.Sequence[builtins.str]] = None,
    settings: typing.Optional[IAgentGraphItemSettings] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f56ab7aacb7878e1d39e5898ac1427926bfc05426f15db694d3fc0ff734dedad(
    targets: typing.Sequence[GraphItem],
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

def _typecheckingstub__66d78e4b33ae25244cb7b81ee8ec05b2cc6797c8ff01f37b427240985f25f7c3(
    value: typing.Optional[IAgentGraphItemSettings],
) -> 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__9fd9e1109152304880a099fddab37e97bb8a4b8eac7d4eaeb9ba5b64b7d20f6c(
    agent: Agent,
) -> 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__0e1b070d38acba21af9e85835b7f9505be50edca1af2b7ad290db29d26ba43e1(
    completion_tokens: typing.Optional[jsii.Number] = None,
    prompt_tokens: typing.Optional[jsii.Number] = None,
    total_tokens: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bbb7f6dd98655a57ace2277474663dd657f6cee9c3240d690e3ac8f55ac13697(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__840ce298a0bc1fb999a434f981e1e65d101bd12087b3f2612a39bad3edc90613(
    value: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c70699746506dd558549f075a6264324f040037434e4d0e45e629d7206702463(
    value: jsii.Number,
) -> 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__6ce51eb3bc0f66424dc100907e6b8645a78f014da089334b5683929638780555(
    instructions: IAgentInstructions,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3820bd4aa216fc45c11762598045b405bfcb54d55efafa184a988ea86af9191c(
    input: IMemoryMessage,
    instructions: IAgentInstructions,
    llm_provider: typing.Optional[LLMProvider] = None,
) -> 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__dd35ef6de1c9651bc7d151f4efc8c1f0db15088148591bc019d5cea3dd7a8bc2(
    inner: typing.Optional[LLMTokens] = None,
    worker: typing.Optional[LLMTokens] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4b3c2c0548517a31cc05aa0d6e475ade9f2a9dec96fd9a34d4bc3edbdabbd7d8(
    value: LLMTokens,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__298b6757d19c9f36a1df243177e78409e0c8bed0b905c0ebcaadf9a658276b48(
    value: LLMTokens,
) -> 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,
    graph_approved: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6fa618f493b9f124cef109e56d0f709f1b78016dbeb7ed55a9eb8cdc733dba99(
    value: builtins.bool,
) -> 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,
    graph_approved: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

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

def _typecheckingstub__1d03c735e160319bb8f7ff2043b62a07dc4ac091a1eb43c315b5be4128fcf92a(
    value: builtins.bool,
) -> 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__f435d83beaf0c0d7ba5fac4b14d448f0cd185e5af1d9aff81d5cfc4147374b61(
    tool_calls: typing.Sequence[ToolCall],
) -> 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[typing.Any]] = 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__28c763e76e4ecb7f7a77fe6c2dba333b644ea0abddac2e6c51dcad464709b85e(
    messages: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7d16546c5c195ddef4391e46da78707938e8cd6d85040e33d40bc00a7120446e(
    input: typing.Optional[builtins.str] = None,
    files: typing.Optional[typing.Sequence[builtins.str]] = None,
    use_worker: typing.Optional[builtins.bool] = None,
    thread_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e9b6b5a079da787d90c8d00f39c55c743d24f5ed3b67480566451861a7cd9ec9(
    tool_call_results: typing.Sequence[ToolCallResult],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__714c96a4dcb9157921296811cd8edcf9f84bf337706dac7c155320ff730bcbf2(
    operations: typing.Sequence[AgenticOperation],
) -> 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__083e27f1b35697c0dc5dd7bec052ea93d4a2fd3d2ee05d66ed6dfd7754537ddb(
    agent_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0958d9b6b5bfc800ebaa305539fc9dcd3ddf83cfd3fd110883c1698d297f6349(
    ignore_cache: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2b9086ebd87942a70c9515c8974e8d9cab5772e11bb9fcb24a227d204d9923f9(
    agentic_interface: AgenticInterface,
    ignore_cache: typing.Optional[builtins.bool] = None,
) -> 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,
    is_multiple: typing.Optional[builtins.bool] = 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: Graph,
) -> 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

def _typecheckingstub__d0421198e44ee66874d3a9ac56a6a99b6dc0f7eaeda89671242d6bf39f995ebb(
    id: builtins.str,
    name: builtins.str,
    summary: builtins.str,
    description: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

def _typecheckingstub__d00f579f8b6ee8853d6931c865ecc5f5725966e5904e8b93d829aa1ee31f452c(
    id: builtins.str,
    name: builtins.str,
    summary: builtins.str,
    description: builtins.str,
    id_to_use_on_graph: builtins.str,
    interface_id: builtins.str,
    is_function: builtins.bool,
    method: builtins.str,
    path: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

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

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

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

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

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

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

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

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

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