"""Protocol for chain-like components."""

@property

def input_keys(self) -> List[str]: ...

@property

def output_keys(self) -> List[str]: ...

"""Base adapter for LangChain components."""

def __init__(self, component: Any):

"""Initialize with a component."""

self.component = component

self.name = self._get_component_name()

def _get_component_name(self) -> str:

"""Get the name of the component."""

if hasattr(self.component, "name"):

return getattr(self.component, "name")

return type(self.component).__name__

def can_adapt(self) -> bool:

"""Check if this adapter can adapt the component."""

raise NotImplementedError("Subclasses must implement this method")

async def process_message(self, text: str) -> str:

"""Process a message with the component."""

raise NotImplementedError("Subclasses must implement this method")

async def process_stream(self, text: str):

"""

# Default implementation: fall back to non-streaming

result = await self.process_message(text)

"""Adapter for components with invoke method."""

def can_adapt(self) -> bool:

"""Check if component has invoke method."""

# Check for Invocable protocol or invoke attribute

has_invoke = isinstance(self.component, Invocable) or hasattr(self.component, "invoke")

# Check for LCEL/pipe operator components (modern LangChain)

is_pipe_component = hasattr(self.component, "__or__") and hasattr(self.component, "__ror__")

return has_invoke or is_pipe_component

async def process_message(self, text: str) -> str:

"""Process message using the invoke method."""

try:

# Prepare input format

input_data = self._prepare_input(text)

# Call invoke with appropriate method

result = await self._invoke(input_data)

# Process output format

return self._process_output(result)

except Exception as e:

logger.exception(f"Error invoking component '{self.name}'")

return f"Error: {str(e)}"

async def process_stream(self, text: str):

"""

# 1. Try modern streaming interfaces in priority order

# Check for stream_invoke method (newest LangChain interface)

if hasattr(self.component, "stream_invoke") and callable(self.component.stream_invoke):

try:

# Prepare input format

input_data = self._prepare_input(text)

# Check if stream_invoke is async

if asyncio.iscoroutinefunction(self.component.stream_invoke):

try:

# Try with prepared input

async for chunk in self.component.stream_invoke(input_data):

yield self._process_chunk(chunk)

return # Successfully used stream_invoke

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

async for chunk in self.component.stream_invoke({"input": input_data}):

yield self._process_chunk(chunk)

return # Successfully used stream_invoke

else:

# Sync stream_invoke

try:

# Try with prepared input

for chunk in self.component.stream_invoke(input_data):

yield self._process_chunk(chunk)

return # Successfully used stream_invoke

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

for chunk in self.component.stream_invoke({"input": input_data}):

yield self._process_chunk(chunk)

return # Successfully used stream_invoke

except Exception as e:

logger.warning(f"Error using stream_invoke for '{self.name}': {e}")

# Continue to next method

# Check for astream_invoke method (async streaming in newer LangChain)

if hasattr(self.component, "astream_invoke") and callable(self.component.astream_invoke):

try:

# Prepare input format

input_data = self._prepare_input(text)

try:

# Try with prepared input

async for chunk in self.component.astream_invoke(input_data):

yield self._process_chunk(chunk)

return # Successfully used astream_invoke

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

async for chunk in self.component.astream_invoke({"input": input_data}):

yield self._process_chunk(chunk)

return # Successfully used astream_invoke

except Exception as e:

logger.warning(f"Error using astream_invoke for '{self.name}': {e}")

# Continue to next method

# 2. Try standard stream methods

if hasattr(self.component, "stream") and callable(self.component.stream):

try:

# Prepare input format

input_data = self._prepare_input(text)

# Check if stream is async

if asyncio.iscoroutinefunction(self.component.stream):

try:

# Try with prepared input

async for chunk in self.component.stream(input_data):

yield self._process_chunk(chunk)

return # Successfully used stream

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

async for chunk in self.component.stream({"input": input_data}):

yield self._process_chunk(chunk)

return # Successfully used stream

else:

# Sync stream

try:

# Try with prepared input

for chunk in self.component.stream(input_data):

yield self._process_chunk(chunk)

return # Successfully used stream

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

for chunk in self.component.stream({"input": input_data}):

yield self._process_chunk(chunk)

return # Successfully used stream

except Exception as e:

logger.warning(f"Error using stream for '{self.name}': {e}")

# Continue to next method

# Check for astream method (older LangChain async streaming)

if hasattr(self.component, "astream") and callable(self.component.astream):

try:

# Prepare input format

input_data = self._prepare_input(text)

try:

# Try with prepared input

async for chunk in self.component.astream(input_data):

yield self._process_chunk(chunk)

return # Successfully used astream

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

async for chunk in self.component.astream({"input": input_data}):

yield self._process_chunk(chunk)

return # Successfully used astream

except Exception as e:

logger.warning(f"Error using astream for '{self.name}': {e}")

# Continue to next method

# 3. Check older or custom interfaces

if hasattr(self.component, "invoke_stream") and callable(self.component.invoke_stream):

try:

# Prepare input format

input_data = self._prepare_input(text)

# Check if invoke_stream is async

if asyncio.iscoroutinefunction(self.component.invoke_stream):

try:

# Try with prepared input

async for chunk in self.component.invoke_stream(input_data):

yield self._process_chunk(chunk)

return # Successfully used invoke_stream

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

async for chunk in self.component.invoke_stream({"input": input_data}):

yield self._process_chunk(chunk)

return # Successfully used invoke_stream

else:

# Sync invoke_stream

try:

# Try with prepared input

for chunk in self.component.invoke_stream(input_data):

yield self._process_chunk(chunk)

return # Successfully used invoke_stream

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

for chunk in self.component.invoke_stream({"input": input_data}):

yield self._process_chunk(chunk)

return # Successfully used invoke_stream

except Exception as e:

logger.warning(f"Error using invoke_stream for '{self.name}': {e}")

# Continue to next method

# 4. Try event-based streaming methods

# Check for astream_events method (event-based streaming in newer LangChain)

if hasattr(self.component, "astream_events") and callable(self.component.astream_events):

try:

# Prepare input format

input_data = self._prepare_input(text)

try:

# Try with prepared input

async for event in self.component.astream_events(input_data):

# Extract useful content from events

if hasattr(event, "event"):

if event.event == "on_llm_new_token":

# Token event - extract text

if hasattr(event, "data") and hasattr(event.data, "token"):

yield event.data.token

elif hasattr(event, "token"):

yield event.token

elif event.event in ["on_chat_model_stream", "on_llm_stream"]:

# Chunk event - extract content

if hasattr(event, "data") and hasattr(event.data, "chunk"):

yield self._process_chunk(event.data.chunk)

elif hasattr(event, "chunk"):

yield self._process_chunk(event.chunk)

elif hasattr(event, "data"):

# Generic event with data

yield self._process_chunk(event.data)

else:

# Unknown event type, convert to string

yield str(event)

return # Successfully used astream_events

except (TypeError, ValueError):

# Try with simple dictionary input

if not isinstance(input_data, dict):

async for event in self.component.astream_events({"input": input_data}):

# Extract useful content from events

if hasattr(event, "event"):

if event.event == "on_llm_new_token":

# Token event - extract text

if hasattr(event, "data") and hasattr(event.data, "token"):

yield event.data.token

elif hasattr(event, "token"):

yield event.token

elif event.event in ["on_chat_model_stream", "on_llm_stream"]:

# Chunk event - extract content

if hasattr(event, "data") and hasattr(event.data, "chunk"):

yield self._process_chunk(event.data.chunk)

elif hasattr(event, "chunk"):

yield self._process_chunk(event.chunk)

elif hasattr(event, "data"):

# Generic event with data

yield self._process_chunk(event.data)

else:

# Unknown event type, convert to string

yield str(event)

return # Successfully used astream_events

except Exception as e:

logger.warning(f"Error using astream_events for '{self.name}': {e}")

# Continue to next method

# Fall back to non-streaming if none of the methods worked

logger.info(f"No compatible streaming method found for '{self.name}', using non-streaming fallback")

result = await self.process_message(text)

yield result

def _process_chunk(self, chunk: Any) -> str:

"""

if chunk is None:

return ""

# String chunks

if isinstance(chunk, str):

return chunk

# Object with content attribute (common in LLM responses)

if hasattr(chunk, "content"):

return str(chunk.content) if chunk.content is not None else ""

# Dictionary format - check common keys in a sensible order

if isinstance(chunk, dict):

for key in ["output", "text", "content", "token", "result", "response", "answer"]:

if key in chunk:

value = chunk[key]

if value is None:

continue

# Handle nested content

if isinstance(value, dict) and "content" in value:

return str(value["content"])

elif isinstance(value, dict) and "text" in value:

return str(value["text"])

elif hasattr(value, "content"):

return str(value.content)

else:

return str(value)

# If no recognized keys are found, convert the whole dict

return str(chunk)

# Default to string representation for any other object

return str(chunk)

def _prepare_input(self, text: str) -> Any:

"""

# Try to determine expected input format

if hasattr(self.component, "input_keys") and self.component.input_keys:

# Use the first input key for components with input_keys

return {self.component.input_keys[0]: text}

# Check method signature for invoke

try:

sig = inspect.signature(self.component.invoke)

first_param = next(iter(sig.parameters.values()), None)

# If first parameter is positional or doesn't have default, use text directly

if first_param and first_param.default == inspect.Parameter.empty:

return text

except (ValueError, TypeError, StopIteration):

pass

# Check for specific input formats based on component type

if hasattr(self.component, "__class__") and hasattr(self.component.__class__, "__name__"):

component_class = self.component.__class__.__name__

# Handle common LangChain components

if component_class in ["ChatPromptTemplate", "PromptTemplate"]:

return {"input": text}

elif component_class in ["ChatOpenAI", "OpenAI", "ChatAnthropic", "Anthropic"]:

return text

# Default to dict format with "input" key

return {"input": text}

async def _invoke(self, input_data: Any) -> Any:

"""

# Check for ainvoke method first (async invoke)

if hasattr(self.component, "ainvoke") and asyncio.iscoroutinefunction(self.component.ainvoke):

# Try direct invocation

try:

return await self.component.ainvoke(input_data)

except (TypeError, ValueError):

# Fall back to dict format if direct invocation fails

if not isinstance(input_data, dict):

return await self.component.ainvoke({"input": input_data})

raise

# Fall back to synchronous invoke

if asyncio.iscoroutinefunction(self.component.invoke):

# Async invoke

try:

return await self.component.invoke(input_data)

except (TypeError, ValueError):

# Fall back to dict format if direct invocation fails

if not isinstance(input_data, dict):

return await self.component.invoke({"input": input_data})

raise

else:

# Run synchronously in executor

loop = asyncio.get_event_loop()

try:

return await loop.run_in_executor(

None, lambda: self.component.invoke(input_data)

)

except (TypeError, ValueError):

# Fall back to dict format if direct invocation fails

if not isinstance(input_data, dict):

return await loop.run_in_executor(

None, lambda: self.component.invoke({"input": input_data})

)

raise

def _process_output(self, result: Any) -> str:

"""

if result is None:

return ""

# String results

if isinstance(result, str):

return result

# Process dictionary results

if isinstance(result, dict):

# Check common keys in a sensible order

for key in ["output", "text", "result", "response", "answer", "content"]:

if key in result:

value = result[key]

if value is None:

continue

# Handle nested content

if isinstance(value, dict) and "content" in value:

return str(value["content"])

elif isinstance(value, dict) and "text" in value:

return str(value["text"])

elif hasattr(value, "content"):

return str(value.content)

else:

return str(value)

# If component has output_keys, try the first one

if hasattr(self.component, "output_keys") and self.component.output_keys:

key = self.component.output_keys[0]

if key in result:

value = result[key]

return str(value) if value is not None else ""

# Handle common LangChain output types

if hasattr(result, "content"):

return str(result.content)

# Default to string representation for any other object

"""Adapter for LangChain agent executors."""

def can_adapt(self) -> bool:

"""Check if component is a LangChain agent executor."""

# Check if it's an AgentExecutor or has expected agent properties

agent_executor_type = False

try:

agent_executor_type = isinstance(self.component, AgentExecutor)

except Exception:

pass

# More strict check for agent properties to avoid false positives

has_agent_attrs = (

hasattr(self.component, 'agent') and

hasattr(self.component, 'tools') and

hasattr(self.component, 'run') and

# Additional check: must have the agent attribute actually set

getattr(self.component, 'agent', None) is not None and

# Additional check: must have tools as a list or tuple

isinstance(getattr(self.component, 'tools', None), (list, tuple))

)

return agent_executor_type or has_agent_attrs

async def process_message(self, text: str) -> str:

"""Process message using agent run method."""

try:

# AgentExecutor expects input in key-value format

# Get the input key

input_key = getattr(self.component, 'input_key', 'input')

# Run the agent with the proper input formatting

if asyncio.iscoroutinefunction(self.component.run):

result = await self.component.run(**{input_key: text})

else:

loop = asyncio.get_event_loop()

result = await loop.run_in_executor(

None, lambda: self.component.run(**{input_key: text})

)

# Handle various result formats

if isinstance(result, str):

return result

elif isinstance(result, dict):

# Agent outputs often have an 'output' key

if 'output' in result:

return str(result['output'])

else:

# If no output key, convert the dict to string

return str(result)

else:

return str(result)

except Exception as e:

logger.exception(f"Error running agent '{self.name}'")

return f"Error: {str(e)}"

async def process_stream(self, text: str):

"""Process streaming with agent."""

# Check if the agent supports streaming

if hasattr(self.component, 'stream') and callable(self.component.stream):

try:

# Get the input key

input_key = getattr(self.component, 'input_key', 'input')

# Stream with proper input format

if asyncio.iscoroutinefunction(self.component.stream):

async for chunk in self.component.stream(**{input_key: text}):

yield self._extract_chunk_content(chunk)

else:

for chunk in self.component.stream(**{input_key: text}):

yield self._extract_chunk_content(chunk)

except Exception as e:

logger.exception(f"Error streaming from agent '{self.name}': {e}")

# Fall back to non-streaming

result = await self.process_message(text)

yield result

else:

# Fall back to non-streaming if stream method not available

result = await self.process_message(text)

yield result

def _extract_chunk_content(self, chunk):

"""Extract content from streaming chunks."""

if isinstance(chunk, str):

return chunk

elif hasattr(chunk, 'content'):

return chunk.content

elif isinstance(chunk, dict):

if 'output' in chunk:

return str(chunk['output'])

elif 'content' in chunk:

return str(chunk['content'])

elif 'text' in chunk:

return str(chunk['text'])

"""Adapter for components with run method."""

def can_adapt(self) -> bool:

"""Check if component has run method."""

return (

isinstance(self.component, RunnableProtocol) or

isinstance(self.component, Runnable) or

hasattr(self.component, "run")

)

async def process_message(self, text: str) -> str:

"""

try:

# First try invoke/ainvoke for modern LangChain Runnables

if isinstance(self.component, Runnable) or hasattr(self.component, "invoke"):

if hasattr(self.component, "ainvoke") and asyncio.iscoroutinefunction(self.component.ainvoke):

try:

# Try with direct input

result = await self.component.ainvoke(text)

except (TypeError, ValueError):

# Try with dictionary input

result = await self.component.ainvoke({"input": text})

else:

# Use synchronous invoke

loop = asyncio.get_event_loop()

try:

result = await loop.run_in_executor(

None, lambda: self.component.invoke(text)

)

except (TypeError, ValueError):

# Try with dictionary input

result = await loop.run_in_executor(

None, lambda: self.component.invoke({"input": text})

)

# Extract result from various formats

if isinstance(result, str):

return result

elif isinstance(result, dict):

for key in ["output", "text", "result", "content", "answer"]:

if key in result:

return str(result[key])

return str(result)

# Fall back to run method

if asyncio.iscoroutinefunction(self.component.run):

try:

# Try direct run

result = await self.component.run(text)

except (TypeError, ValueError):

# Try with dictionary input

result = await self.component.run({"input": text})

else:

# Run synchronously

loop = asyncio.get_event_loop()

try:

result = await loop.run_in_executor(None, self.component.run, text)

except (TypeError, ValueError):

# Try with dictionary input

result = await loop.run_in_executor(

None, lambda: self.component.run({"input": text})

)

# Process result

if result is None:

return ""

# Extract text from result

if isinstance(result, str):

return result

elif isinstance(result, dict):

for key in ["output", "text", "result", "content", "answer"]:

if key in result:

return str(result[key])

return str(result)

except Exception as e:

logger.exception(f"Error running component '{self.name}'")

return f"Error: {str(e)}"

async def process_stream(self, text: str):

"""

# Try all modern LangChain streaming interfaces in priority order

# 1. First check for modern Runnable streaming interfaces

if isinstance(self.component, Runnable) or hasattr(self.component, "stream"):

# astream is preferred for async streaming (modern LangChain)

if hasattr(self.component, "astream") and callable(self.component.astream):

try:

# Try various input formats

try:

# Direct input

async for chunk in self.component.astream(text):

yield self._extract_chunk_content(chunk)

except (TypeError, ValueError):

# Dictionary input

async for chunk in self.component.astream({"input": text}):

yield self._extract_chunk_content(chunk)

return # Successfully used astream

except Exception as e:

logger.warning(f"Error using astream for '{self.name}': {e}")

# Continue to next method

# Try stream method (synchronous streaming)

if hasattr(self.component, "stream") and callable(self.component.stream):

try:

# Try with direct input

try:

if asyncio.iscoroutinefunction(self.component.stream):

# Async implementation

async for chunk in self.component.stream(text):

yield self._extract_chunk_content(chunk)

else:

# Sync implementation

for chunk in self.component.stream(text):

yield self._extract_chunk_content(chunk)

return # Successfully used stream

except (TypeError, ValueError):

# Try with dictionary input

if asyncio.iscoroutinefunction(self.component.stream):

# Async implementation

async for chunk in self.component.stream({"input": text}):

yield self._extract_chunk_content(chunk)

else:

# Sync implementation

for chunk in self.component.stream({"input": text}):

yield self._extract_chunk_content(chunk)

return # Successfully used stream

except Exception as e:

logger.warning(f"Error using stream for '{self.name}': {e}")

# Continue to next method

# 2. Check for advanced streaming interfaces like astream_events and astream_log

if hasattr(self.component, "astream_events") and callable(self.component.astream_events):

try:

# Try with direct input

try:

async for event in self.component.astream_events(text):

# Process event types (end, tokens, etc.)

if hasattr(event, "event") and event.event == "on_llm_new_token":

if hasattr(event, "data") and hasattr(event.data, "token"):

yield event.data.token

elif hasattr(event, "token"):

yield event.token

elif hasattr(event, "data"):

yield str(event.data)

elif hasattr(event, "event") and event.event in ["on_chat_model_stream", "on_llm_stream"]:

if hasattr(event, "data") and hasattr(event.data, "chunk"):

yield self._extract_chunk_content(event.data.chunk)

elif hasattr(event, "chunk"):

yield self._extract_chunk_content(event.chunk)

elif hasattr(event, "data"):

yield str(event.data)

except (TypeError, ValueError):

# Try with dictionary input

async for event in self.component.astream_events({"input": text}):

# Process event types

if hasattr(event, "event") and event.event == "on_llm_new_token":

if hasattr(event, "data") and hasattr(event.data, "token"):

yield event.data.token

elif hasattr(event, "token"):

yield event.token

elif hasattr(event, "data"):

yield str(event.data)

elif hasattr(event, "event") and event.event in ["on_chat_model_stream", "on_llm_stream"]:

if hasattr(event, "data") and hasattr(event.data, "chunk"):

yield self._extract_chunk_content(event.data.chunk)

elif hasattr(event, "chunk"):

yield self._extract_chunk_content(event.chunk)

elif hasattr(event, "data"):

yield str(event.data)

return # Successfully used astream_events

except Exception as e:

logger.warning(f"Error using astream_events for '{self.name}': {e}")

# Continue to next method

# Check for astream_log method (contains full intermediate steps)

if hasattr(self.component, "astream_log") and callable(self.component.astream_log):

try:

# Try with direct input

try:

async for log_entry in self.component.astream_log(text):

# Extract text from log entries

if isinstance(log_entry, str):

yield log_entry

elif isinstance(log_entry, dict):

if "output" in log_entry:

# Yield the output field

yield self._extract_chunk_content(log_entry["output"])

elif "final_output" in log_entry:

# Yield the final output

yield self._extract_chunk_content(log_entry["final_output"])

elif "intermediate_steps" in log_entry:

# Try to get something useful from intermediate steps

for step in log_entry["intermediate_steps"]:

if hasattr(step, "output") or (isinstance(step, tuple) and len(step) > 1):

output = step.output if hasattr(step, "output") else step[1]

yield self._extract_chunk_content(output)

except (TypeError, ValueError):

# Try with dictionary input

async for log_entry in self.component.astream_log({"input": text}):

# Extract text from log entries

if isinstance(log_entry, str):

yield log_entry

elif isinstance(log_entry, dict):

if "output" in log_entry:

# Yield the output field

yield self._extract_chunk_content(log_entry["output"])

elif "final_output" in log_entry:

# Yield the final output

yield self._extract_chunk_content(log_entry["final_output"])

elif "intermediate_steps" in log_entry:

# Try to get something useful from intermediate steps

for step in log_entry["intermediate_steps"]:

if hasattr(step, "output") or (isinstance(step, tuple) and len(step) > 1):

output = step.output if hasattr(step, "output") else step[1]

yield self._extract_chunk_content(output)

return # Successfully used astream_log

except Exception as e:

logger.warning(f"Error using astream_log for '{self.name}': {e}")

# Continue to next method

# 3. Check for older or custom interfaces

# Check for run_stream method (used by some LangChain Runnables)

if hasattr(self.component, "run_stream") and callable(self.component.run_stream):

try:

# Check if run_stream is async

if asyncio.iscoroutinefunction(self.component.run_stream):

try:

# Try with direct text

async for chunk in self.component.run_stream(text):

yield self._extract_chunk_content(chunk)

except (TypeError, ValueError):

# Try with dictionary

async for chunk in self.component.run_stream({"input": text}):

yield self._extract_chunk_content(chunk)

else:

# Sync run_stream

try:

# Try with direct text

for chunk in self.component.run_stream(text):

yield self._extract_chunk_content(chunk)

except (TypeError, ValueError):

# Try with dictionary

for chunk in self.component.run_stream({"input": text}):

yield self._extract_chunk_content(chunk)

return # Successfully used run_stream

except Exception as e:

logger.warning(f"Error using run_stream for '{self.name}': {e}")

# Continue to next method

# If we get here, none of the streaming methods worked

# Fall back to non-streaming

logger.info(f"No compatible streaming method found for '{self.name}', using non-streaming fallback")

result = await self.process_message(text)

yield result

def _extract_chunk_content(self, chunk: Any) -> str:

"""

# String chunks

if isinstance(chunk, str):

return chunk

# Object with content attribute

if hasattr(chunk, "content"):

return str(chunk.content)

# Dictionary format with content

if isinstance(chunk, dict):

if "content" in chunk:

return str(chunk["content"])

elif "text" in chunk:

return str(chunk["text"])

elif "token" in chunk:

return str(chunk["token"])

elif "output" in chunk:

# Try to extract output

if isinstance(chunk["output"], str):

return chunk["output"]

elif hasattr(chunk["output"], "content"):

return str(chunk["output"].content)

elif isinstance(chunk["output"], dict) and "content" in chunk["output"]:

return str(chunk["output"]["content"])

# If we can't extract specific fields, convert the whole dict to string

return str(chunk)

# Any other object, convert to string

"""Adapter for language model components."""

def can_adapt(self) -> bool:

"""Check if component is a language model."""

return (isinstance(self.component, (BaseLanguageModel, LLM)) or

hasattr(self.component, "predict") or

hasattr(self.component, "generate") or

hasattr(self.component, "stream"))

async def process_message(self, text: str) -> str:

"""Process message using LLM methods."""

try:

# Try predict if available

if hasattr(self.component, "predict"):

if asyncio.iscoroutinefunction(self.component.predict):

result = await self.component.predict(text=text)

else:

loop = asyncio.get_event_loop()

result = await loop.run_in_executor(

None, lambda: self.component.predict(text=text)

)

return result if result is not None else ""

# Fall back to generate

if hasattr(self.component, "generate"):

if asyncio.iscoroutinefunction(self.component.generate):

generation = await self.component.generate([text])

else: