agentlin-client 0.1.0__py3-none-any.whl

agentlin_client/types/conversations/web_search_tool_call_param.py

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["WebSearchToolCallParam", "Action", "ActionSearch", "ActionSearchSource", "ActionOpenPage", "ActionFind"]
+
+
+class ActionSearchSource(TypedDict, total=False):
+    type: Required[Literal["url"]]
+    """The type of source. Always `url`."""
+
+    url: Required[str]
+    """The URL of the source."""
+
+
+class ActionSearch(TypedDict, total=False):
+    query: Required[str]
+    """The search query."""
+
+    type: Required[Literal["search"]]
+    """The action type."""
+
+    sources: Iterable[ActionSearchSource]
+    """The sources used in the search."""
+
+
+class ActionOpenPage(TypedDict, total=False):
+    type: Required[Literal["open_page"]]
+    """The action type."""
+
+    url: Required[str]
+    """The URL opened by the model."""
+
+
+class ActionFind(TypedDict, total=False):
+    pattern: Required[str]
+    """The pattern or text to search for within the page."""
+
+    type: Required[Literal["find"]]
+    """The action type."""
+
+    url: Required[str]
+    """The URL of the page searched for the pattern."""
+
+
+Action: TypeAlias = Union[ActionSearch, ActionOpenPage, ActionFind]
+
+
+class WebSearchToolCallParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the web search tool call."""
+
+    action: Required[Action]
+    """
+    An object describing the specific action taken in this web search call. Includes
+    details on how the model used the web (search, open_page, find).
+    """
+
+    status: Required[Literal["in_progress", "searching", "completed", "failed"]]
+    """The status of the web search tool call."""
+
+    type: Required[Literal["web_search_call"]]
+    """The type of the web search tool call. Always `web_search_call`."""

agentlin_client/types/mcp_tool_filter.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .._models import BaseModel
+
+__all__ = ["McpToolFilter"]
+
+
+class McpToolFilter(BaseModel):
+    read_only: Optional[bool] = None
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: Optional[List[str]] = None
+    """List of allowed tool names."""

agentlin_client/types/mcp_tool_filter_param.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["McpToolFilterParam"]
+
+
+class McpToolFilterParam(TypedDict, total=False):
+    read_only: bool
+    """Indicates whether or not a tool modifies data or is read-only.
+
+    If an MCP server is
+    [annotated with `readOnlyHint`](https://modelcontextprotocol.io/specification/2025-06-18/schema#toolannotations-readonlyhint),
+    it will match this filter.
+    """
+
+    tool_names: SequenceNotStr[str]
+    """List of allowed tool names."""

agentlin_client/types/model_response_properties_standard.py

@@ -0,0 +1,87 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ModelResponsePropertiesStandard"]
+
+
+class ModelResponsePropertiesStandard(BaseModel):
+    metadata: Optional[Dict[str, str]] = None
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format, and querying for objects via API or the dashboard.
+
+    Keys are strings with a maximum length of 64 characters. Values are strings with
+    a maximum length of 512 characters.
+    """
+
+    prompt_cache_key: Optional[str] = None
+    """
+    Used by OpenAI to cache responses for similar requests to optimize your cache
+    hit rates. Replaces the `user` field.
+    [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
+    """
+
+    safety_identifier: Optional[str] = None
+    """
+    A stable identifier used to help detect users of your application that may be
+    violating OpenAI's usage policies. The IDs should be a string that uniquely
+    identifies each user. We recommend hashing their username or email address, in
+    order to avoid sending us any identifying information.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+    """
+
+    service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] = None
+    """Specifies the processing type used for serving the request.
+
+    - If set to 'auto', then the request will be processed with the service tier
+      configured in the Project settings. Unless otherwise configured, the Project
+      will use 'default'.
+    - If set to 'default', then the request will be processed with the standard
+      pricing and performance for the selected model.
+    - If set to '[flex](https://platform.openai.com/docs/guides/flex-processing)' or
+      '[priority](https://openai.com/api-priority-processing/)', then the request
+      will be processed with the corresponding service tier.
+    - When not set, the default behavior is 'auto'.
+
+    When the `service_tier` parameter is set, the response body will include the
+    `service_tier` value based on the processing mode actually used to serve the
+    request. This response value may be different from the value set in the
+    parameter.
+    """
+
+    temperature: Optional[float] = None
+    """What sampling temperature to use, between 0 and 2.
+
+    Higher values like 0.8 will make the output more random, while lower values like
+    0.2 will make it more focused and deterministic. We generally recommend altering
+    this or `top_p` but not both.
+    """
+
+    top_logprobs: Optional[int] = None
+    """
+    An integer between 0 and 20 specifying the number of most likely tokens to
+    return at each token position, each with an associated log probability.
+    """
+
+    top_p: Optional[float] = None
+    """
+    An alternative to sampling with temperature, called nucleus sampling, where the
+    model considers the results of the tokens with top_p probability mass. So 0.1
+    means only the tokens comprising the top 10% probability mass are considered.
+
+    We generally recommend altering this or `temperature` but not both.
+    """
+
+    user: Optional[str] = None
+    """This field is being replaced by `safety_identifier` and `prompt_cache_key`.
+
+    Use `prompt_cache_key` instead to maintain caching optimizations. A stable
+    identifier for your end-users. Used to boost cache hit rates by better bucketing
+    similar requests and to help OpenAI detect and prevent abuse.
+    [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
+    """

agentlin_client/types/response.py

@@ -0,0 +1,166 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+from .response_properties import ResponseProperties
+from .conversations.input_item import InputItem
+from .conversations.mcp_tool_call import McpToolCall
+from .conversations.mcp_list_tools import McpListTools
+from .conversations.output_message import OutputMessage
+from .conversations.reasoning_item import ReasoningItem
+from .conversations.custom_tool_call import CustomToolCall
+from .conversations.computer_tool_call import ComputerToolCall
+from .conversations.function_tool_call import FunctionToolCall
+from .conversations.image_gen_tool_call import ImageGenToolCall
+from .conversations.mcp_approval_request import McpApprovalRequest
+from .conversations.web_search_tool_call import WebSearchToolCall
+from .model_response_properties_standard import ModelResponsePropertiesStandard
+from .conversations.file_search_tool_call import FileSearchToolCall
+from .conversations.local_shell_tool_call import LocalShellToolCall
+from .conversations.code_interpreter_tool_call import CodeInterpreterToolCall
+
+__all__ = [
+    "Response",
+    "ResponseError",
+    "ResponseIncompleteDetails",
+    "ResponseOutput",
+    "ResponseUsage",
+    "ResponseUsageInputTokensDetails",
+    "ResponseUsageOutputTokensDetails",
+]
+
+
+class ResponseError(BaseModel):
+    code: Literal[
+        "server_error",
+        "rate_limit_exceeded",
+        "invalid_prompt",
+        "vector_store_timeout",
+        "invalid_image",
+        "invalid_image_format",
+        "invalid_base64_image",
+        "invalid_image_url",
+        "image_too_large",
+        "image_too_small",
+        "image_parse_error",
+        "image_content_policy_violation",
+        "invalid_image_mode",
+        "image_file_too_large",
+        "unsupported_image_media_type",
+        "empty_image_file",
+        "failed_to_download_image",
+        "image_file_not_found",
+    ]
+    """The error code for the response."""
+
+    message: str
+    """A human-readable description of the error."""
+
+
+class ResponseIncompleteDetails(BaseModel):
+    reason: Optional[Literal["max_output_tokens", "content_filter"]] = None
+    """The reason why the response is incomplete."""
+
+
+ResponseOutput: TypeAlias = Annotated[
+    Union[
+        OutputMessage,
+        FileSearchToolCall,
+        FunctionToolCall,
+        WebSearchToolCall,
+        ComputerToolCall,
+        ReasoningItem,
+        ImageGenToolCall,
+        CodeInterpreterToolCall,
+        LocalShellToolCall,
+        McpToolCall,
+        McpListTools,
+        McpApprovalRequest,
+        CustomToolCall,
+    ],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class ResponseUsageInputTokensDetails(BaseModel):
+    cached_tokens: int
+    """
+    The number of tokens that were retrieved from the cache.
+    [More on prompt caching](https://platform.openai.com/docs/guides/prompt-caching).
+    """
+
+
+class ResponseUsageOutputTokensDetails(BaseModel):
+    reasoning_tokens: int
+    """The number of reasoning tokens."""
+
+
+class ResponseUsage(BaseModel):
+    input_tokens: int
+    """The number of input tokens."""
+
+    input_tokens_details: ResponseUsageInputTokensDetails
+    """A detailed breakdown of the input tokens."""
+
+    output_tokens: int
+    """The number of output tokens."""
+
+    output_tokens_details: ResponseUsageOutputTokensDetails
+    """A detailed breakdown of the output tokens."""
+
+    total_tokens: int
+    """The total number of tokens used."""
+
+
+class Response(ModelResponsePropertiesStandard, ResponseProperties):
+    id: str
+    """Unique identifier for this Response."""
+
+    created_at: float
+    """Unix timestamp (in seconds) of when this Response was created."""
+
+    error: Optional[ResponseError] = None
+    """An error object returned when the model fails to generate a Response."""
+
+    incomplete_details: Optional[ResponseIncompleteDetails] = None
+    """Details about why the response is incomplete."""
+
+    instructions: Union[str, List[InputItem], None] = None
+    """A system (or developer) message inserted into the model's context.
+
+    When using along with `previous_response_id`, the instructions from a previous
+    response will not be carried over to the next response. This makes it simple to
+    swap out system (or developer) messages in new responses.
+    """
+
+    object: Literal["response"]
+    """The object type of this resource - always set to `response`."""
+
+    output: List[ResponseOutput]
+    """An array of content items generated by the model.
+
+    - The length and order of items in the `output` array is dependent on the
+      model's response.
+    - Rather than accessing the first item in the `output` array and assuming it's
+      an `assistant` message with the content generated by the model, you might
+      consider using the `output_text` property where supported in SDKs.
+    """
+
+    parallel_tool_calls: bool
+    """Whether to allow the model to run tool calls in parallel."""
+
+    status: Optional[Literal["completed", "failed", "in_progress", "cancelled", "queued", "incomplete"]] = None
+    """The status of the response generation.
+
+    One of `completed`, `failed`, `in_progress`, `cancelled`, `queued`, or
+    `incomplete`.
+    """
+
+    usage: Optional[ResponseUsage] = None
+    """
+    Represents token usage details including input tokens, output tokens, a
+    breakdown of output tokens, and the total tokens used.
+    """