perplexityai 0.7.2__py3-none-any.whl → 0.9.0__py3-none-any.whl

perplexity/types/chat/completion_create_params.py

@@ -2,89 +2,229 @@
 
 from __future__ import annotations
 
-from typing import Iterable, Optional
-from typing_extensions import Literal, Required, TypedDict
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
 
 from ..._types import SequenceNotStr
-from ..shared_params.chat_message import ChatMessage
-
-__all__ = ["CompletionCreateParams", "WebSearchOptions", "WebSearchOptionsUserLocation"]
+from ..shared_params.chat_message_input import ChatMessageInput
+
+__all__ = [
+    "CompletionCreateParams",
+    "DebugParams",
+    "ResponseFormat",
+    "ResponseFormatResponseFormatText",
+    "ResponseFormatResponseFormatJsonSchema",
+    "ResponseFormatResponseFormatJsonSchemaJsonSchema",
+    "ResponseFormatResponseFormatRegex",
+    "ResponseFormatResponseFormatRegexRegex",
+    "Tool",
+    "ToolFunction",
+    "ToolFunctionParameters",
+    "WebSearchOptions",
+    "WebSearchOptionsUserLocation",
+]
 
 
 class CompletionCreateParams(TypedDict, total=False):
-    messages: Required[Iterable[ChatMessage]]
-    """A list of messages comprising the conversation so far"""
+    messages: Required[Iterable[ChatMessageInput]]
+
+    model: Required[str]
+
+    _debug_pro_search: bool
+
+    _inputs: Optional[Iterable[int]]
+
+    _is_browser_agent: Optional[bool]
+
+    _prompt_token_length: Optional[int]
+
+    best_of: Optional[int]
+
+    country: Optional[str]
+
+    cum_logprobs: Optional[bool]
 
-    model: Required[Literal["sonar", "sonar-pro", "sonar-deep-research", "sonar-reasoning", "sonar-reasoning-pro"]]
-    """The name of the model that will complete your prompt"""
+    debug_params: Optional[DebugParams]
 
-    disable_search: bool
-    """Disables web search completely - model uses only training data"""
+    disable_search: Optional[bool]
 
-    enable_search_classifier: bool
-    """Enables classifier that decides if web search is needed"""
+    diverse_first_token: Optional[bool]
+
+    enable_search_classifier: Optional[bool]
+
+    file_workspace_id: Optional[str]
+
+    frequency_penalty: Optional[float]
+
+    has_image_url: bool
+
+    image_domain_filter: Optional[SequenceNotStr[str]]
+
+    image_format_filter: Optional[SequenceNotStr[str]]
 
     last_updated_after_filter: Optional[str]
-    """Only include content last updated after this date (YYYY-MM-DD)"""
 
     last_updated_before_filter: Optional[str]
-    """Only include content last updated before this date (YYYY-MM-DD)"""
 
-    reasoning_effort: Optional[Literal["low", "medium", "high"]]
-    """Controls computational effort for sonar-deep-research model.
+    latitude: Optional[float]
+
+    logprobs: Optional[bool]
+
+    longitude: Optional[float]
+
+    max_tokens: Optional[int]
+
+    n: Optional[int]
+
+    num_images: int
+
+    num_search_results: int
+
+    parallel_tool_calls: Optional[bool]
+
+    presence_penalty: Optional[float]
+
+    ranking_model: Optional[str]
+
+    reasoning_effort: Optional[Literal["minimal", "low", "medium", "high"]]
+
+    response_format: Optional[ResponseFormat]
+
+    response_metadata: Optional[Dict[str, object]]
 
-    Higher effort = more thorough but more tokens
-    """
+    return_images: Optional[bool]
 
-    return_images: bool
-    """Whether to include images in search results"""
+    return_related_questions: Optional[bool]
 
-    return_related_questions: bool
-    """Whether to return related questions"""
+    safe_search: Optional[bool]
 
     search_after_date_filter: Optional[str]
-    """Only include content published after this date (YYYY-MM-DD)"""
 
     search_before_date_filter: Optional[str]
-    """Only include content published before this date (YYYY-MM-DD)"""
 
     search_domain_filter: Optional[SequenceNotStr[str]]
-    """List of domains to limit search results to. Use '-' prefix to exclude domains"""
+
+    search_internal_properties: Optional[Dict[str, object]]
 
     search_mode: Optional[Literal["web", "academic", "sec"]]
-    """
-    Type of search: 'web' for general, 'academic' for scholarly, 'sec' for SEC
-    filings
-    """
 
     search_recency_filter: Optional[Literal["hour", "day", "week", "month", "year"]]
-    """Filter results by how recently they were published"""
+
+    search_tenant: Optional[str]
+
+    stop: Union[str, SequenceNotStr[str], None]
+
+    stream: Optional[bool]
+
+    temperature: Optional[float]
+
+    tool_choice: Optional[Literal["none", "auto", "required"]]
+
+    tools: Optional[Iterable[Tool]]
+
+    top_k: Optional[int]
+
+    top_logprobs: Optional[int]
+
+    top_p: Optional[float]
+
+    updated_after_timestamp: Optional[int]
+
+    updated_before_timestamp: Optional[int]
 
     web_search_options: WebSearchOptions
 
 
+class DebugParams(TypedDict, total=False):
+    summarizer_model_override: Optional[str]
+
+    summarizer_prompt_override: Optional[str]
+
+
+class ResponseFormatResponseFormatText(TypedDict, total=False):
+    type: Required[Literal["text"]]
+
+
+class ResponseFormatResponseFormatJsonSchemaJsonSchema(TypedDict, total=False):
+    schema: Required[Dict[str, object]]
+
+    description: Optional[str]
+
+    name: Optional[str]
+
+    strict: Optional[bool]
+
+
+class ResponseFormatResponseFormatJsonSchema(TypedDict, total=False):
+    json_schema: Required[ResponseFormatResponseFormatJsonSchemaJsonSchema]
+
+    type: Required[Literal["json_schema"]]
+
+
+class ResponseFormatResponseFormatRegexRegex(TypedDict, total=False):
+    regex: Required[str]
+
+    description: Optional[str]
+
+    name: Optional[str]
+
+    strict: Optional[bool]
+
+
+class ResponseFormatResponseFormatRegex(TypedDict, total=False):
+    regex: Required[ResponseFormatResponseFormatRegexRegex]
+
+    type: Required[Literal["regex"]]
+
+
+ResponseFormat: TypeAlias = Union[
+    ResponseFormatResponseFormatText, ResponseFormatResponseFormatJsonSchema, ResponseFormatResponseFormatRegex
+]
+
+
+class ToolFunctionParameters(TypedDict, total=False):
+    properties: Required[Dict[str, object]]
+
+    type: Required[str]
+
+    additional_properties: Optional[bool]
+
+    required: Optional[SequenceNotStr[str]]
+
+
+class ToolFunction(TypedDict, total=False):
+    description: Required[str]
+
+    name: Required[str]
+
+    parameters: Required[ToolFunctionParameters]
+
+    strict: Optional[bool]
+
+
+class Tool(TypedDict, total=False):
+    function: Required[ToolFunction]
+
+    type: Required[Literal["function"]]
+
+
 class WebSearchOptionsUserLocation(TypedDict, total=False):
     city: Optional[str]
 
     country: Optional[str]
-    """Two-letter ISO country code"""
 
     latitude: Optional[float]
 
     longitude: Optional[float]
 
     region: Optional[str]
-    """State/province name"""
 
 
 class WebSearchOptions(TypedDict, total=False):
-    image_search_relevance_enhanced: bool
-    """Improves relevance of image search results"""
+    image_results_enhanced_relevance: bool
 
     search_context_size: Literal["low", "medium", "high"]
-    """
-    Amount of search context retrieved: low (cost-saving), medium (balanced), high
-    (comprehensive)
-    """
 
-    user_location: WebSearchOptionsUserLocation
+    search_type: Literal["fast", "pro", "auto"]
+
+    user_location: Optional[WebSearchOptionsUserLocation]

perplexity/types/chat/completion_create_response.py

@@ -1,30 +1,33 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import List, Optional
+from typing_extensions import Literal
 
 from ..._models import BaseModel
+from ..shared.choice import Choice
 from ..shared.usage_info import UsageInfo
-from ..shared.chat_choice import ChatChoice
-from ..shared.search_result import SearchResult
+from ..shared.api_public_search_result import APIPublicSearchResult
 
 __all__ = ["CompletionCreateResponse"]
 
 
 class CompletionCreateResponse(BaseModel):
     id: str
-    """Unique identifier for the chat completion"""
 
-    choices: List[ChatChoice]
+    choices: List[Choice]
 
     created: int
-    """Unix timestamp of creation"""
 
     model: str
-    """The model used"""
-
-    object: str
 
     usage: UsageInfo
 
-    search_results: Optional[List[SearchResult]] = None
-    """Search results used in generating the response"""
+    citations: Optional[List[str]] = None
+
+    object: Optional[str] = None
+
+    search_results: Optional[List[APIPublicSearchResult]] = None
+
+    status: Optional[Literal["PENDING", "COMPLETED"]] = None
+
+    type: Optional[Literal["message", "info", "end_of_stream"]] = None

perplexity/types/search_create_params.py

@@ -12,51 +12,27 @@ __all__ = ["SearchCreateParams"]
 
 class SearchCreateParams(TypedDict, total=False):
     query: Required[Union[str, SequenceNotStr[str]]]
-    """Search query string or array of query strings to search for"""
 
     country: Optional[str]
-    """Country code to bias search results towards (e.g., 'US', 'GB', 'CA')"""
 
     last_updated_after_filter: Optional[str]
-    """Only include results last updated after this date (ISO 8601 format: YYYY-MM-DD)"""
 
     last_updated_before_filter: Optional[str]
-    """
-    Only include results last updated before this date (ISO 8601 format: YYYY-MM-DD)
-    """
 
     max_results: int
-    """Maximum number of search results to return"""
 
     max_tokens: int
-    """Maximum number of tokens to return across all results"""
 
     max_tokens_per_page: int
-    """Maximum number of tokens to return per individual search result"""
 
     safe_search: Optional[bool]
-    """Enable safe search filtering to exclude adult content"""
 
     search_after_date_filter: Optional[str]
-    """Only include results published after this date (ISO 8601 format: YYYY-MM-DD)"""
 
     search_before_date_filter: Optional[str]
-    """Only include results published before this date (ISO 8601 format: YYYY-MM-DD)"""
 
     search_domain_filter: Optional[SequenceNotStr[str]]
-    """
-    List of domains to restrict search results to (e.g., ['example.com',
-    'another.com'])
-    """
 
     search_mode: Optional[Literal["web", "academic", "sec"]]
-    """
-    Type of search to perform: 'web' for general web search, 'academic' for
-    scholarly articles, 'sec' for SEC filings
-    """
 
     search_recency_filter: Optional[Literal["hour", "day", "week", "month", "year"]]
-    """
-    Filter results by how recently they were published (hour, day, week, month, or
-    year)
-    """

perplexity/types/search_create_response.py

@@ -9,24 +9,17 @@ __all__ = ["SearchCreateResponse", "Result"]
 
 class Result(BaseModel):
     snippet: str
-    """A brief excerpt or summary of the page content"""
 
     title: str
-    """The title of the search result page"""
 
     url: str
-    """The URL of the search result page"""
 
     date: Optional[str] = None
-    """The publication date of the content (if available)"""
 
     last_updated: Optional[str] = None
-    """When the content was last updated (if available)"""
 
 
 class SearchCreateResponse(BaseModel):
     id: str
-    """Unique identifier for this search request"""
 
     results: List[Result]
-    """Array of search result pages matching the query"""

perplexity/types/shared/__init__.py

@@ -1,6 +1,7 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .choice import Choice as Choice
 from .usage_info import UsageInfo as UsageInfo
-from .chat_choice import ChatChoice as ChatChoice
-from .chat_message import ChatMessage as ChatMessage
-from .search_result import SearchResult as SearchResult
+from .chat_message_input import ChatMessageInput as ChatMessageInput
+from .chat_message_output import ChatMessageOutput as ChatMessageOutput
+from .api_public_search_result import APIPublicSearchResult as APIPublicSearchResult

perplexity/types/shared/{search_result.py → api_public_search_result.py}

@@ -4,12 +4,16 @@ from typing import Optional
 
 from ..._models import BaseModel
 
-__all__ = ["SearchResult"]
+__all__ = ["APIPublicSearchResult"]
 
 
-class SearchResult(BaseModel):
+class APIPublicSearchResult(BaseModel):
     title: str
 
     url: str
 
     date: Optional[str] = None
+
+    last_updated: Optional[str] = None
+
+    snippet: Optional[str] = None

perplexity/types/shared/chat_message_input.py

@@ -0,0 +1,212 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from .api_public_search_result import APIPublicSearchResult
+
+__all__ = [
+    "ChatMessageInput",
+    "ContentStructuredContent",
+    "ContentStructuredContentChatMessageContentTextChunk",
+    "ContentStructuredContentChatMessageContentImageChunk",
+    "ContentStructuredContentChatMessageContentImageChunkImageURL",
+    "ContentStructuredContentChatMessageContentImageChunkImageURLURL",
+    "ContentStructuredContentChatMessageContentFileChunk",
+    "ContentStructuredContentChatMessageContentFileChunkFileURL",
+    "ContentStructuredContentChatMessageContentFileChunkFileURLURL",
+    "ContentStructuredContentChatMessageContentPdfChunk",
+    "ContentStructuredContentChatMessageContentPdfChunkPdfURL",
+    "ContentStructuredContentChatMessageContentPdfChunkPdfURLURL",
+    "ContentStructuredContentChatMessageContentVideoChunk",
+    "ContentStructuredContentChatMessageContentVideoChunkVideoURL",
+    "ContentStructuredContentChatMessageContentVideoChunkVideoURLVideoURL",
+    "ReasoningStep",
+    "ReasoningStepAgentProgress",
+    "ReasoningStepBrowserAgent",
+    "ReasoningStepBrowserToolExecution",
+    "ReasoningStepExecutePython",
+    "ReasoningStepFetchURLContent",
+    "ReasoningStepFileAttachmentSearch",
+    "ReasoningStepWebSearch",
+    "ToolCall",
+    "ToolCallFunction",
+]
+
+
+class ContentStructuredContentChatMessageContentTextChunk(BaseModel):
+    text: str
+
+    type: Literal["text"]
+
+
+class ContentStructuredContentChatMessageContentImageChunkImageURLURL(BaseModel):
+    url: str
+
+
+ContentStructuredContentChatMessageContentImageChunkImageURL: TypeAlias = Union[
+    ContentStructuredContentChatMessageContentImageChunkImageURLURL, str
+]
+
+
+class ContentStructuredContentChatMessageContentImageChunk(BaseModel):
+    image_url: ContentStructuredContentChatMessageContentImageChunkImageURL
+
+    type: Literal["image_url"]
+
+
+class ContentStructuredContentChatMessageContentFileChunkFileURLURL(BaseModel):
+    url: str
+
+
+ContentStructuredContentChatMessageContentFileChunkFileURL: TypeAlias = Union[
+    ContentStructuredContentChatMessageContentFileChunkFileURLURL, str
+]
+
+
+class ContentStructuredContentChatMessageContentFileChunk(BaseModel):
+    file_url: ContentStructuredContentChatMessageContentFileChunkFileURL
+
+    type: Literal["file_url"]
+
+    file_name: Optional[str] = None
+
+
+class ContentStructuredContentChatMessageContentPdfChunkPdfURLURL(BaseModel):
+    url: str
+
+
+ContentStructuredContentChatMessageContentPdfChunkPdfURL: TypeAlias = Union[
+    ContentStructuredContentChatMessageContentPdfChunkPdfURLURL, str
+]
+
+
+class ContentStructuredContentChatMessageContentPdfChunk(BaseModel):
+    pdf_url: ContentStructuredContentChatMessageContentPdfChunkPdfURL
+
+    type: Literal["pdf_url"]
+
+
+class ContentStructuredContentChatMessageContentVideoChunkVideoURLVideoURL(BaseModel):
+    url: str
+
+    frame_interval: Union[str, int, None] = None
+
+
+ContentStructuredContentChatMessageContentVideoChunkVideoURL: TypeAlias = Union[
+    ContentStructuredContentChatMessageContentVideoChunkVideoURLVideoURL, str
+]
+
+
+class ContentStructuredContentChatMessageContentVideoChunk(BaseModel):
+    type: Literal["video_url"]
+
+    video_url: ContentStructuredContentChatMessageContentVideoChunkVideoURL
+
+
+ContentStructuredContent: TypeAlias = Union[
+    ContentStructuredContentChatMessageContentTextChunk,
+    ContentStructuredContentChatMessageContentImageChunk,
+    ContentStructuredContentChatMessageContentFileChunk,
+    ContentStructuredContentChatMessageContentPdfChunk,
+    ContentStructuredContentChatMessageContentVideoChunk,
+]
+
+
+class ReasoningStepAgentProgress(BaseModel):
+    action: Optional[str] = None
+
+    screenshot: Optional[str] = None
+
+    url: Optional[str] = None
+
+
+class ReasoningStepBrowserAgent(BaseModel):
+    result: str
+
+    url: str
+
+
+class ReasoningStepBrowserToolExecution(BaseModel):
+    tool: Dict[str, object]
+
+
+class ReasoningStepExecutePython(BaseModel):
+    code: str
+
+    result: str
+
+
+class ReasoningStepFetchURLContent(BaseModel):
+    contents: List[APIPublicSearchResult]
+
+
+class ReasoningStepFileAttachmentSearch(BaseModel):
+    attachment_urls: List[str]
+
+
+class ReasoningStepWebSearch(BaseModel):
+    search_keywords: List[str]
+
+    search_results: List[APIPublicSearchResult]
+
+
+class ReasoningStep(BaseModel):
+    thought: str
+
+    type: Literal[
+        "web_search",
+        "fetch_url_content",
+        "execute_python",
+        "agent_progress",
+        "browser_agent",
+        "browser_tool_execution",
+        "file_attachment_search",
+    ]
+
+    agent_progress: Optional[ReasoningStepAgentProgress] = None
+    """Agent progress class for live-browsing updates"""
+
+    browser_agent: Optional[ReasoningStepBrowserAgent] = None
+    """Browser agent step summary class"""
+
+    browser_tool_execution: Optional[ReasoningStepBrowserToolExecution] = None
+    """Tool input for kicking off browser tool automation"""
+
+    execute_python: Optional[ReasoningStepExecutePython] = None
+    """Code generation step details wrapper class"""
+
+    fetch_url_content: Optional[ReasoningStepFetchURLContent] = None
+    """Fetch url content step details wrapper class"""
+
+    file_attachment_search: Optional[ReasoningStepFileAttachmentSearch] = None
+    """File attachment search step details wrapper class"""
+
+    web_search: Optional[ReasoningStepWebSearch] = None
+    """Web search step details wrapper class"""
+
+
+class ToolCallFunction(BaseModel):
+    arguments: Optional[str] = None
+
+    name: Optional[str] = None
+
+
+class ToolCall(BaseModel):
+    id: Optional[str] = None
+
+    function: Optional[ToolCallFunction] = None
+
+    type: Optional[Literal["function"]] = None
+
+
+class ChatMessageInput(BaseModel):
+    content: Union[str, List[ContentStructuredContent]]
+
+    role: Literal["system", "user", "assistant", "tool"]
+    """Chat roles enum"""
+
+    reasoning_steps: Optional[List[ReasoningStep]] = None
+
+    tool_calls: Optional[List[ToolCall]] = None