qtype 0.0.12__py3-none-any.whl → 0.1.3__py3-none-any.whl

qtype/interpreter/chat/vercel.py

@@ -1,314 +0,0 @@
-"""
-Pydantic models for Vercel AI SDK UI types.
-
-This module reproduces the exact TypeScript type shapes from the AI SDK UI
-as Pydantic models for use in Python implementations.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Literal, Union
-
-from pydantic import BaseModel, Field
-
-
-# Provider metadata
-class ProviderMetadata(BaseModel):
-    """Provider-specific metadata.
-
-    Reproduces: ProviderMetadata from ui/ui-message-chunks.ts
-    """
-
-    model_config = {"extra": "allow"}
-
-
-# UI Message Parts
-class TextUIPart(BaseModel):
-    """A text part of a message.
-
-    Reproduces: TextUIPart from ui/ui-messages.ts
-    """
-
-    type: Literal["text"] = "text"
-    text: str
-    state: Literal["streaming", "done"] | None = None
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class ReasoningUIPart(BaseModel):
-    """A reasoning part of a message.
-
-    Reproduces: ReasoningUIPart from ui/ui-messages.ts
-    """
-
-    type: Literal["reasoning"] = "reasoning"
-    text: str
-    state: Literal["streaming", "done"] | None = None
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class SourceUrlUIPart(BaseModel):
-    """A source URL part of a message.
-
-    Reproduces: SourceUrlUIPart from ui/ui-messages.ts
-    """
-
-    type: Literal["source-url"] = "source-url"
-    source_id: str = Field(alias="sourceId")
-    url: str
-    title: str | None = None
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class SourceDocumentUIPart(BaseModel):
-    """A document source part of a message.
-
-    Reproduces: SourceDocumentUIPart from ui/ui-messages.ts
-    """
-
-    type: Literal["source-document"] = "source-document"
-    source_id: str = Field(alias="sourceId")
-    media_type: str = Field(alias="mediaType")
-    title: str
-    filename: str | None = None
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class FileUIPart(BaseModel):
-    """A file part of a message.
-
-    Reproduces: FileUIPart from ui/ui-messages.ts
-    """
-
-    type: Literal["file"] = "file"
-    media_type: str = Field(alias="mediaType")
-    filename: str | None = None
-    url: str
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class StepStartUIPart(BaseModel):
-    """A step boundary part of a message.
-
-    Reproduces: StepStartUIPart from ui/ui-messages.ts
-    """
-
-    type: Literal["step-start"] = "step-start"
-
-
-# Union type for UI message parts
-UIMessagePart = Union[
-    TextUIPart,
-    ReasoningUIPart,
-    SourceUrlUIPart,
-    SourceDocumentUIPart,
-    FileUIPart,
-    StepStartUIPart,
-]
-
-
-# UI Message
-class UIMessage(BaseModel):
-    """AI SDK UI Message.
-
-    Reproduces: UIMessage from ui/ui-messages.ts
-    """
-
-    id: str
-    role: Literal["system", "user", "assistant"]
-    metadata: dict[str, Any] | None = None
-    parts: list[UIMessagePart]
-
-
-# Chat Request (the request body sent from frontend)
-class ChatRequest(BaseModel):
-    """Chat request format sent from AI SDK UI/React.
-
-    Reproduces: ChatRequest from ui/chat-transport.ts
-    """
-
-    id: str  # chatId
-    messages: list[UIMessage]
-    trigger: Literal["submit-message", "regenerate-message"]
-    message_id: str | None = Field(default=None, alias="messageId")
-
-
-# UI Message Chunks (streaming events)
-class TextStartChunk(BaseModel):
-    """Text start chunk.
-
-    Reproduces: TextStartChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["text-start"] = "text-start"
-    id: str
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class TextDeltaChunk(BaseModel):
-    """Text delta chunk.
-
-    Reproduces: TextDeltaChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["text-delta"] = "text-delta"
-    id: str
-    delta: str
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class TextEndChunk(BaseModel):
-    """Text end chunk.
-
-    Reproduces: TextEndChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["text-end"] = "text-end"
-    id: str
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class ReasoningStartChunk(BaseModel):
-    """Reasoning start chunk.
-
-    Reproduces: ReasoningStartChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["reasoning-start"] = "reasoning-start"
-    id: str
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class ReasoningDeltaChunk(BaseModel):
-    """Reasoning delta chunk.
-
-    Reproduces: ReasoningDeltaChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["reasoning-delta"] = "reasoning-delta"
-    id: str
-    delta: str
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class ReasoningEndChunk(BaseModel):
-    """Reasoning end chunk.
-
-    Reproduces: ReasoningEndChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["reasoning-end"] = "reasoning-end"
-    id: str
-    provider_metadata: ProviderMetadata | None = Field(
-        default=None, alias="providerMetadata"
-    )
-
-
-class ErrorChunk(BaseModel):
-    """Error chunk.
-
-    Reproduces: ErrorChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["error"] = "error"
-    error_text: str = Field(alias="errorText")
-
-
-class StartStepChunk(BaseModel):
-    """Start step chunk.
-
-    Reproduces: StartStepChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["start-step"] = "start-step"
-
-
-class FinishStepChunk(BaseModel):
-    """Finish step chunk.
-
-    Reproduces: FinishStepChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["finish-step"] = "finish-step"
-
-
-class StartChunk(BaseModel):
-    """Start chunk.
-
-    Reproduces: StartChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["start"] = "start"
-    message_id: str | None = Field(default=None, alias="messageId")
-    message_metadata: dict[str, Any] | None = Field(
-        default=None, alias="messageMetadata"
-    )
-
-
-class FinishChunk(BaseModel):
-    """Finish chunk.
-
-    Reproduces: FinishChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["finish"] = "finish"
-    message_metadata: dict[str, Any] | None = Field(
-        default=None, alias="messageMetadata"
-    )
-
-
-class AbortChunk(BaseModel):
-    """Abort chunk.
-
-    Reproduces: AbortChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["abort"] = "abort"
-
-
-class MessageMetadataChunk(BaseModel):
-    """Message metadata chunk.
-
-    Reproduces: MessageMetadataChunk from ui/ui-message-chunks.ts
-    """
-
-    type: Literal["message-metadata"] = "message-metadata"
-    message_metadata: dict[str, Any] = Field(alias="messageMetadata")
-
-
-# Union type for all UI message chunks
-UIMessageChunk = Union[
-    TextStartChunk,
-    TextDeltaChunk,
-    TextEndChunk,
-    ReasoningStartChunk,
-    ReasoningDeltaChunk,
-    ReasoningEndChunk,
-    ErrorChunk,
-    StartStepChunk,
-    FinishStepChunk,
-    StartChunk,
-    FinishChunk,
-    AbortChunk,
-    MessageMetadataChunk,
-]

qtype/interpreter/exceptions.py

@@ -1,10 +0,0 @@
-from typing import Any
-
-
-class InterpreterError(Exception):
-    """Base exception class for ProtoGen interpreter errors."""
-
-    def __init__(self, message: str, details: Any = None) -> None:
-        super().__init__(message)
-        self.message = message
-        self.details = details

qtype/interpreter/step.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from qtype.interpreter.exceptions import InterpreterError
-from qtype.interpreter.steps import (
-    agent,
-    condition,
-    decoder,
-    llm_inference,
-    prompt_template,
-    search,
-    tool,
-)
-from qtype.semantic.model import (
-    Agent,
-    Condition,
-    Decoder,
-    Flow,
-    LLMInference,
-    PromptTemplate,
-    Search,
-    Step,
-    Tool,
-    Variable,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def execute_step(step: Step, **kwargs: dict[str, Any]) -> list[Variable]:
-    """Execute a single step within a flow.
-
-    Args:
-        step: The step to execute.
-        **kwargs: Additional keyword arguments.
-    """
-    logger.debug(f"Executing step: {step.id} with kwargs: {kwargs}")
-
-    unset_inputs = [input for input in step.inputs if not input.is_set()]
-    if unset_inputs:
-        raise InterpreterError(
-            f"The following inputs are required but have no values: {', '.join([input.id for input in unset_inputs])}"
-        )
-
-    if isinstance(step, Agent):
-        return agent.execute(step=step, **kwargs)  # type: ignore[arg-type]
-    elif isinstance(step, Condition):
-        return condition.execute(condition=step, **kwargs)
-    elif isinstance(step, Decoder):
-        return decoder.execute(step=step, **kwargs)  # type: ignore[arg-type]
-    elif isinstance(step, Flow):
-        from .flow import execute_flow
-
-        return execute_flow(step, **kwargs)  # type: ignore[arg-type]
-    elif isinstance(step, LLMInference):
-        return llm_inference.execute(step, **kwargs)  # type: ignore[arg-type]
-    elif isinstance(step, PromptTemplate):
-        return prompt_template.execute(step, **kwargs)  # type: ignore[arg-type]
-    elif isinstance(step, Search):
-        return search.execute(step, **kwargs)  # type: ignore[arg-type]
-    elif isinstance(step, Tool):
-        return tool.execute(step, **kwargs)  # type: ignore[arg-type]
-    else:
-        # Handle other step types if necessary
-        raise InterpreterError(f"Unsupported step type: {type(step).__name__}")

qtype/interpreter/steps/agent.py

@@ -1,114 +0,0 @@
-import asyncio
-import importlib
-import logging
-from typing import Any
-
-from llama_index.core.agent.workflow import ReActAgent
-from llama_index.core.base.llms.types import ChatMessage as LlamaChatMessage
-from llama_index.core.tools import AsyncBaseTool, FunctionTool
-from llama_index.core.workflow import Context
-from llama_index.core.workflow.handler import WorkflowHandler  # type: ignore
-
-from qtype.dsl.domain_types import ChatMessage
-from qtype.interpreter.conversions import (
-    from_chat_message,
-    to_chat_message,
-    to_llm,
-    to_memory,
-)
-from qtype.interpreter.exceptions import InterpreterError
-from qtype.semantic.model import Agent, APITool, PythonFunctionTool, Variable
-
-logger = logging.getLogger(__name__)
-
-
-def to_llama_tool(tool: PythonFunctionTool) -> AsyncBaseTool:
-    """Convert a qtype Tool to a LlamaIndex Tool."""
-    # We want to get the function named by the tool -- get ".tools.<tool_name>"
-    # This assumes the tool name matches a function in the .tools module
-    module = importlib.import_module(tool.module_path)
-    function = getattr(module, tool.function_name, None)
-    if function is None:
-        raise ValueError(
-            f"Tool function '{tool.function_name}' not found in module '{tool.module_path}'."
-        )
-
-    return FunctionTool.from_defaults(
-        fn=function, name=tool.name, description=tool.description
-    )
-
-
-def execute(agent: Agent, **kwargs: dict[str, Any]) -> list[Variable]:
-    """Execute an agent step.
-
-    Args:
-        agent: The agent step to execute.
-        **kwargs: Additional keyword arguments.
-    """
-    logger.debug(f"Executing agent step: {agent.id}")
-    if len(agent.outputs) != 1:
-        raise InterpreterError(
-            "LLMInference step must have exactly one output variable."
-        )
-    output_variable = agent.outputs[0]
-
-    # prepare the input for the agent
-    if len(agent.inputs) != 1:
-        # TODO: Support multiple inputs by shoving it into the chat history?
-        raise InterpreterError(
-            "Agent step must have exactly one input variable."
-        )
-
-    input_variable = agent.inputs[0]
-    if input_variable.type == ChatMessage:
-        input: LlamaChatMessage | str = to_chat_message(input_variable.value)  # type: ignore
-    else:
-        input: LlamaChatMessage | str = input_variable.value  # type: ignore
-
-    # Pepare the tools
-    # TODO: support api tools
-    if any(isinstance(tool, APITool) for tool in agent.tools):
-        raise NotImplementedError(
-            "APITool is not supported in the current implementation. Please use PythonFunctionTool."
-        )
-    tools = [
-        to_llama_tool(tool)  # type: ignore
-        for tool in (agent.tools if agent.tools else [])
-    ]
-
-    # prep memory
-    # Note to_memory is a cached resource so this will get existing memory if available
-    memory = (
-        to_memory(kwargs.get("session_id"), agent.memory)
-        if agent.memory
-        else None
-    )
-
-    # Run the agent
-    async def run_agent() -> WorkflowHandler:
-        logger.debug(
-            f"Starting agent '{agent.id}' execution with input length: {len(str(input))} (ReAct mode)"
-        )
-        re_agent = ReActAgent(
-            name=agent.id,
-            tools=tools,  # type: ignore
-            system_prompt=agent.system_message,
-            llm=to_llm(agent.model, agent.system_message),  # type: ignore
-        )
-        ctx = Context(re_agent)  # type: ignore
-        # TODO: implement checkpoint_callback to call stream_fn?
-        handler = re_agent.run(input, chat_memory=memory, ctx=ctx)
-        result = await handler
-        logger.debug(
-            f"Agent '{agent.id}' execution completed successfully (ReAct mode)"
-        )
-        return result
-
-    result = asyncio.run(run_agent())
-
-    if output_variable.type == ChatMessage:
-        output_variable.value = from_chat_message(result.response)  # type: ignore
-    else:
-        output_variable.value = result.response.content  # type: ignore
-
-    return agent.outputs

qtype/interpreter/steps/condition.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from qtype.semantic.model import Condition, Variable
-
-
-def execute(condition: Condition, **kwargs: dict[str, Any]) -> list[Variable]:
-    """Execute a condition step.
-
-    Args:
-        condition: The condition step to execute.
-
-    Returns:
-        A list of variables that are set based on the condition evaluation.
-    """
-    from qtype.interpreter.step import execute_step
-
-    if not condition.inputs:
-        raise ValueError(
-            "Condition step requires at least one input variable."
-        )
-
-    if len(condition.inputs) != 1:
-        raise ValueError(
-            f"Condition step {condition.id} must have exactly one input, found {len(condition.inputs)}."
-        )
-    input_var = condition.inputs[0]
-    if condition.equals.value == input_var.value:  # type: ignore
-        # If the condition is met, return the outputs
-        return execute_step(condition.then, **kwargs)
-    elif condition.else_:
-        return execute_step(condition.else_, **kwargs)
-    else:
-        # If no else branch is defined, return an empty list
-        return []

qtype/interpreter/steps/decoder.py

@@ -1,88 +0,0 @@
-import json
-import xml.etree.ElementTree as ET
-from typing import Any
-
-from qtype.dsl.model import DecoderFormat
-from qtype.semantic.model import Decoder, Variable
-
-
-def parse_json(input: str) -> dict[str, Any]:
-    """Parse a JSON string into a Python object."""
-    try:
-        cleaned_response = input.strip()
-        if cleaned_response.startswith("```json"):
-            cleaned_response = cleaned_response[7:]
-        if cleaned_response.endswith("```"):
-            cleaned_response = cleaned_response[:-3]
-        cleaned_response = cleaned_response.strip()
-
-        # Parse the JSON
-        parsed = json.loads(cleaned_response)
-        if not isinstance(parsed, dict):
-            raise ValueError(f"Parsed JSON is not an object: {parsed}")
-        return parsed
-    except json.JSONDecodeError as e:
-        raise ValueError(f"Invalid JSON input: {e}")
-
-
-def parse_xml(input: str) -> dict[str, Any]:
-    """Parse an XML string into a Python object."""
-    try:
-        cleaned_response = input.strip()
-        if cleaned_response.startswith("```xml"):
-            cleaned_response = cleaned_response[6:]
-        if cleaned_response.endswith("```"):
-            cleaned_response = cleaned_response[:-3]
-        cleaned_response = cleaned_response.strip()
-
-        cleaned_response = cleaned_response.replace("&", "&")
-        tree = ET.fromstring(cleaned_response)
-        result = {c.tag: c.text for c in tree}
-
-        return result
-    except Exception as e:
-        raise ValueError(f"Invalid XML input: {e}")
-
-
-def parse(input: str, format: DecoderFormat) -> dict[str, Any]:
-    if format == DecoderFormat.json:
-        return parse_json(input)
-    elif format == DecoderFormat.xml:
-        return parse_xml(input)
-    else:
-        raise ValueError(
-            f"Unsupported decoder format: {format}. Supported formats are: {DecoderFormat.json}, {DecoderFormat.xml}."
-        )
-
-
-def execute(decoder: Decoder, **kwargs: dict[str, Any]) -> list[Variable]:
-    """Execute a decoder step with the provided arguments.
-
-    Args:
-        decoder: The decoder step to execute.
-        **kwargs: Additional keyword arguments.
-    """
-
-    if len(decoder.inputs) != 1:
-        raise ValueError(
-            f"Decoder step {decoder.id} must have exactly one input, found {len(decoder.inputs)}."
-        )
-
-    # get the string value to decode
-    input = decoder.inputs[0].value
-    if not isinstance(input, str):
-        raise ValueError(
-            f"Input to decoder step {decoder.id} must be a string, found {type(input).__name__}."
-        )
-
-    result_dict = parse(input, decoder.format)
-
-    # Set the output variables with the parsed results
-    for output in decoder.outputs:
-        if output.id in result_dict:
-            output.value = result_dict[output.id]
-        else:
-            raise ValueError(
-                f"Output variable {output.id} not found in decoded result: {result_dict}"
-            )
-    return decoder.outputs  # type: ignore[no-any-return]