qtype 0.0.16__py3-none-any.whl → 0.1.1__py3-none-any.whl

qtype/interpreter/chat/chat_api.py

@@ -1,237 +0,0 @@
-from __future__ import annotations
-
-import logging
-import uuid
-from collections.abc import Generator
-from typing import Any
-
-from fastapi import FastAPI
-from fastapi.responses import StreamingResponse
-
-from qtype.dsl.base_types import PrimitiveTypeEnum
-from qtype.dsl.domain_types import ChatContent, ChatMessage, MessageRole
-from qtype.interpreter.chat.file_conversions import file_to_content
-from qtype.interpreter.chat.vercel import (
-    ChatRequest,
-    ErrorChunk,
-    FinishChunk,
-    StartChunk,
-    TextDeltaChunk,
-    TextEndChunk,
-    TextStartChunk,
-    UIMessage,
-)
-from qtype.interpreter.flow import execute_flow
-from qtype.interpreter.streaming_helpers import create_streaming_generator
-from qtype.semantic.model import Flow
-
-
-def _ui_request_to_domain_type(request: ChatRequest) -> list[ChatMessage]:
-    """
-    Convert a ChatRequest to domain-specific ChatMessages.
-
-    Processes all UI messages from the AI SDK UI/React request format.
-    Returns the full conversation history for context.
-    """
-    if not request.messages:
-        raise ValueError("No messages provided in request.")
-
-    # Convert each UIMessage to a domain-specific ChatMessage
-    return [
-        _ui_message_to_domain_type(message) for message in request.messages
-    ]
-
-
-def _ui_message_to_domain_type(message: UIMessage) -> ChatMessage:
-    """
-    Convert a UIMessage to a domain-specific ChatMessage.
-
-    Creates one block for each part in the message content.
-    """
-    blocks = []
-
-    for part in message.parts:
-        if part.type == "text":
-            blocks.append(
-                ChatContent(type=PrimitiveTypeEnum.text, content=part.text)
-            )
-        elif part.type == "reasoning":
-            blocks.append(
-                ChatContent(type=PrimitiveTypeEnum.text, content=part.text)
-            )
-        elif part.type == "file":
-            blocks.append(
-                file_to_content(part.url)  # type: ignore
-            )
-        elif part.type.startswith("tool-"):
-            raise NotImplementedError(
-                "Tool call part handling is not implemented yet."
-            )
-        elif part.type == "dynamic-tool":
-            raise NotImplementedError(
-                "Dynamic tool part handling is not implemented yet."
-            )
-        elif part.type == "step-start":
-            # Step boundaries might not need content blocks
-            continue
-        elif part.type in ["source-url", "source-document"]:
-            raise NotImplementedError(
-                "Source part handling is not implemented yet."
-            )
-        elif part.type.startswith("data-"):
-            raise NotImplementedError(
-                "Data part handling is not implemented yet."
-            )
-        else:
-            # Log unknown part types for debugging
-            raise ValueError(f"Unknown part type: {part.type}")
-
-    # If no blocks were created, raise an error
-    if not blocks:
-        raise ValueError(
-            "No valid content blocks created from UIMessage parts."
-        )
-
-    return ChatMessage(
-        role=MessageRole(message.role),
-        blocks=blocks,
-    )
-
-
-def create_chat_flow_endpoint(app: FastAPI, flow: Flow) -> None:
-    """
-    Create a chat endpoint for the given Flow.
-
-    This creates an endpoint at /flows/{flow_id}/chat that follows the
-    AI SDK UI/React request format and responds with streaming data.
-
-    Args:
-        app: The FastAPI application instance
-        flow: The Flow to create an endpoint for
-    """
-    flow_id = flow.id
-
-    async def handle_chat_data(request: ChatRequest) -> StreamingResponse:
-        """Handle chat requests for the specific flow."""
-
-        try:
-            # Convert AI SDK UI request to domain ChatMessages
-            messages = _ui_request_to_domain_type(request)
-            if not len(messages):
-                raise ValueError("No input messages received")
-
-            # Pop the last message as the current input
-            current_input = messages.pop()
-            if current_input.role != MessageRole.user:
-                raise ValueError(
-                    f"Unexpected input {current_input} from non user role: {current_input.role}"
-                )
-
-            flow_copy = flow.model_copy(deep=True)
-
-            input_variable = [
-                var for var in flow_copy.inputs if var.type == ChatMessage
-            ][0]
-            input_variable.value = current_input
-
-            # Pass conversation context to flow execution for memory population
-            execution_kwargs: Any = {
-                "session_id": request.id,  # Use request ID as session identifier
-                "conversation_history": messages,
-            }
-
-            # Create a streaming generator for the flow execution
-            stream_generator, result_future = create_streaming_generator(
-                execute_flow, flow_copy, **execution_kwargs
-            )
-        except Exception as e:
-            error_chunk = ErrorChunk(errorText=str(e))
-            response = StreamingResponse(
-                [
-                    f"data: {error_chunk.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-                ],
-                media_type="text/plain; charset=utf-8",
-            )
-            response.headers["x-vercel-ai-ui-message-stream"] = "v1"
-            return response
-
-        # Create generator that formats messages according to AI SDK UI streaming protocol
-        def vercel_ai_formatter() -> Generator[str, None, None]:
-            """Format stream data according to AI SDK UI streaming protocol."""
-
-            # Send start chunk
-            start_chunk = StartChunk(messageId=str(uuid.uuid4()))  # type: ignore
-            yield f"data: {start_chunk.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-
-            # Track text content for proper streaming
-            text_id = str(uuid.uuid4())
-            text_started = False
-
-            for step, message in stream_generator:
-                if isinstance(message, ChatMessage):
-                    # Convert ChatMessage to text content
-                    content = " ".join(
-                        [
-                            block.content
-                            for block in message.blocks
-                            if hasattr(block, "content") and block.content
-                        ]
-                    )
-                    if content.strip():
-                        # Start text block if not started
-                        if not text_started:
-                            text_start = TextStartChunk(id=text_id)
-                            yield f"data: {text_start.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-                            text_started = True
-
-                        # Send text delta
-                        text_delta = TextDeltaChunk(id=text_id, delta=content)
-                        yield f"data: {text_delta.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-                else:
-                    # Handle other message types as text deltas
-                    text_content = str(message)
-                    if text_content.strip():
-                        # Start text block if not started
-                        if not text_started:
-                            text_start = TextStartChunk(id=text_id)
-                            yield f"data: {text_start.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-                            text_started = True
-
-                        # Send text delta
-                        text_delta = TextDeltaChunk(
-                            id=text_id, delta=text_content
-                        )
-                        yield f"data: {text_delta.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-
-            # End text block if it was started
-            if text_started:
-                text_end = TextEndChunk(id=text_id)
-                yield f"data: {text_end.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-
-            # Send finish chunk
-            try:
-                result_future.result(timeout=5.0)
-                finish_chunk = FinishChunk()
-                yield f"data: {finish_chunk.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-            except Exception as e:
-                # Send error
-                error_chunk = ErrorChunk(errorText=str(e))
-                logging.error(
-                    f"Error during flow execution: {e}", exc_info=True
-                )
-                yield f"data: {error_chunk.model_dump_json(by_alias=True, exclude_none=True)}\n\n"
-
-        response = StreamingResponse(
-            vercel_ai_formatter(), media_type="text/plain; charset=utf-8"
-        )
-        response.headers["x-vercel-ai-ui-message-stream"] = "v1"
-        return response
-
-    # Add the endpoint to the FastAPI app
-    app.post(
-        f"/flows/{flow_id}/chat",
-        tags=["chat"],
-        summary=f"Chat with {flow_id} flow",
-        description=flow.description,
-        response_class=StreamingResponse,
-    )(handle_chat_data)

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,
-    Invoke,
-    LLMInference,
-    PromptTemplate,
-    Search,
-    Step,
-    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, Invoke):
-        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__}")