agentlin-client 0.1.0__py3-none-any.whl

agentlin_client/types/response_tool_param.py

@@ -0,0 +1,491 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .._types import SequenceNotStr
+from .mcp_tool_filter_param import McpToolFilterParam
+
+__all__ = [
+    "ResponseToolParam",
+    "Function",
+    "FileSearch",
+    "FileSearchFilters",
+    "FileSearchFiltersComparisonFilter",
+    "FileSearchFiltersCompoundFilter",
+    "FileSearchFiltersCompoundFilterFilter",
+    "FileSearchFiltersCompoundFilterFilterComparisonFilter",
+    "FileSearchRankingOptions",
+    "ComputerUsePreview",
+    "WebSearchTool",
+    "WebSearchToolFilters",
+    "WebSearchToolUserLocation",
+    "Mcp",
+    "McpAllowedTools",
+    "McpRequireApproval",
+    "McpRequireApprovalMcpToolApprovalFilter",
+    "CodeInterpreter",
+    "CodeInterpreterContainer",
+    "CodeInterpreterContainerCodeInterpreterToolAuto",
+    "ImageGeneration",
+    "ImageGenerationInputImageMask",
+    "LocalShell",
+    "Custom",
+    "CustomFormat",
+    "CustomFormatText",
+    "CustomFormatGrammar",
+    "WebSearchPreviewTool",
+    "WebSearchPreviewToolUserLocation",
+]
+
+
+class Function(TypedDict, total=False):
+    name: Required[str]
+    """The name of the function to call."""
+
+    parameters: Required[Optional[Dict[str, object]]]
+    """A JSON schema object describing the parameters of the function."""
+
+    strict: Required[Optional[bool]]
+    """Whether to enforce strict parameter validation. Default `true`."""
+
+    type: Required[Literal["function"]]
+    """The type of the function tool. Always `function`."""
+
+    description: Optional[str]
+    """A description of the function.
+
+    Used by the model to determine whether or not to call the function.
+    """
+
+
+class FileSearchFiltersComparisonFilter(TypedDict, total=False):
+    key: Required[str]
+    """The key to compare against the value."""
+
+    type: Required[Literal["eq", "ne", "gt", "gte", "lt", "lte"]]
+    """
+    Specifies the comparison operator: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`,
+    `nin`.
+
+    - `eq`: equals
+    - `ne`: not equal
+    - `gt`: greater than
+    - `gte`: greater than or equal
+    - `lt`: less than
+    - `lte`: less than or equal
+    - `in`: in
+    - `nin`: not in
+    """
+
+    value: Required[Union[str, float, bool, SequenceNotStr[Union[str, float]]]]
+    """
+    The value to compare against the attribute key; supports string, number, or
+    boolean types.
+    """
+
+
+class FileSearchFiltersCompoundFilterFilterComparisonFilter(TypedDict, total=False):
+    key: Required[str]
+    """The key to compare against the value."""
+
+    type: Required[Literal["eq", "ne", "gt", "gte", "lt", "lte"]]
+    """
+    Specifies the comparison operator: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`,
+    `nin`.
+
+    - `eq`: equals
+    - `ne`: not equal
+    - `gt`: greater than
+    - `gte`: greater than or equal
+    - `lt`: less than
+    - `lte`: less than or equal
+    - `in`: in
+    - `nin`: not in
+    """
+
+    value: Required[Union[str, float, bool, SequenceNotStr[Union[str, float]]]]
+    """
+    The value to compare against the attribute key; supports string, number, or
+    boolean types.
+    """
+
+
+FileSearchFiltersCompoundFilterFilter: TypeAlias = Union[FileSearchFiltersCompoundFilterFilterComparisonFilter, object]
+
+
+class FileSearchFiltersCompoundFilter(TypedDict, total=False):
+    filters: Required[Iterable[FileSearchFiltersCompoundFilterFilter]]
+    """Array of filters to combine.
+
+    Items can be `ComparisonFilter` or `CompoundFilter`.
+    """
+
+    type: Required[Literal["and", "or"]]
+    """Type of operation: `and` or `or`."""
+
+
+FileSearchFilters: TypeAlias = Union[FileSearchFiltersComparisonFilter, FileSearchFiltersCompoundFilter]
+
+
+class FileSearchRankingOptions(TypedDict, total=False):
+    ranker: Literal["auto", "default-2024-11-15"]
+    """The ranker to use for the file search."""
+
+    score_threshold: float
+    """The score threshold for the file search, a number between 0 and 1.
+
+    Numbers closer to 1 will attempt to return only the most relevant results, but
+    may return fewer results.
+    """
+
+
+class FileSearch(TypedDict, total=False):
+    type: Required[Literal["file_search"]]
+    """The type of the file search tool. Always `file_search`."""
+
+    vector_store_ids: Required[SequenceNotStr[str]]
+    """The IDs of the vector stores to search."""
+
+    filters: Optional[FileSearchFilters]
+    """A filter to apply."""
+
+    max_num_results: int
+    """The maximum number of results to return.
+
+    This number should be between 1 and 50 inclusive.
+    """
+
+    ranking_options: FileSearchRankingOptions
+    """Ranking options for search."""
+
+
+class ComputerUsePreview(TypedDict, total=False):
+    display_height: Required[int]
+    """The height of the computer display."""
+
+    display_width: Required[int]
+    """The width of the computer display."""
+
+    environment: Required[Literal["windows", "mac", "linux", "ubuntu", "browser"]]
+    """The type of computer environment to control."""
+
+    type: Required[Literal["computer_use_preview"]]
+    """The type of the computer use tool. Always `computer_use_preview`."""
+
+
+class WebSearchToolFilters(TypedDict, total=False):
+    allowed_domains: Optional[SequenceNotStr[str]]
+    """Allowed domains for the search.
+
+    If not provided, all domains are allowed. Subdomains of the provided domains are
+    allowed as well.
+
+    Example: `["pubmed.ncbi.nlm.nih.gov"]`
+    """
+
+
+class WebSearchToolUserLocation(TypedDict, total=False):
+    city: Optional[str]
+    """Free text input for the city of the user, e.g. `San Francisco`."""
+
+    country: Optional[str]
+    """
+    The two-letter [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1) of
+    the user, e.g. `US`.
+    """
+
+    region: Optional[str]
+    """Free text input for the region of the user, e.g. `California`."""
+
+    timezone: Optional[str]
+    """
+    The [IANA timezone](https://timeapi.io/documentation/iana-timezones) of the
+    user, e.g. `America/Los_Angeles`.
+    """
+
+    type: Literal["approximate"]
+    """The type of location approximation. Always `approximate`."""
+
+
+class WebSearchTool(TypedDict, total=False):
+    type: Required[Literal["web_search", "web_search_2025_08_26"]]
+    """The type of the web search tool.
+
+    One of `web_search` or `web_search_2025_08_26`.
+    """
+
+    filters: Optional[WebSearchToolFilters]
+    """Filters for the search."""
+
+    search_context_size: Literal["low", "medium", "high"]
+    """High level guidance for the amount of context window space to use for the
+    search.
+
+    One of `low`, `medium`, or `high`. `medium` is the default.
+    """
+
+    user_location: Optional[WebSearchToolUserLocation]
+    """The approximate location of the user."""
+
+
+McpAllowedTools: TypeAlias = Union[SequenceNotStr[str], McpToolFilterParam]
+
+
+class McpRequireApprovalMcpToolApprovalFilter(TypedDict, total=False):
+    always: McpToolFilterParam
+    """A filter object to specify which tools are allowed."""
+
+    never: McpToolFilterParam
+    """A filter object to specify which tools are allowed."""
+
+
+McpRequireApproval: TypeAlias = Union[McpRequireApprovalMcpToolApprovalFilter, Literal["always", "never"]]
+
+
+class Mcp(TypedDict, total=False):
+    server_label: Required[str]
+    """A label for this MCP server, used to identify it in tool calls."""
+
+    type: Required[Literal["mcp"]]
+    """The type of the MCP tool. Always `mcp`."""
+
+    allowed_tools: Optional[McpAllowedTools]
+    """List of allowed tool names or a filter object."""
+
+    authorization: str
+    """
+    An OAuth access token that can be used with a remote MCP server, either with a
+    custom MCP server URL or a service connector. Your application must handle the
+    OAuth authorization flow and provide the token here.
+    """
+
+    connector_id: Literal[
+        "connector_dropbox",
+        "connector_gmail",
+        "connector_googlecalendar",
+        "connector_googledrive",
+        "connector_microsoftteams",
+        "connector_outlookcalendar",
+        "connector_outlookemail",
+        "connector_sharepoint",
+    ]
+    """Identifier for service connectors, like those available in ChatGPT.
+
+    One of `server_url` or `connector_id` must be provided. Learn more about service
+    connectors
+    [here](https://platform.openai.com/docs/guides/tools-remote-mcp#connectors).
+
+    Currently supported `connector_id` values are:
+
+    - Dropbox: `connector_dropbox`
+    - Gmail: `connector_gmail`
+    - Google Calendar: `connector_googlecalendar`
+    - Google Drive: `connector_googledrive`
+    - Microsoft Teams: `connector_microsoftteams`
+    - Outlook Calendar: `connector_outlookcalendar`
+    - Outlook Email: `connector_outlookemail`
+    - SharePoint: `connector_sharepoint`
+    """
+
+    headers: Optional[Dict[str, str]]
+    """Optional HTTP headers to send to the MCP server.
+
+    Use for authentication or other purposes.
+    """
+
+    require_approval: Optional[McpRequireApproval]
+    """Specify which of the MCP server's tools require approval."""
+
+    server_description: str
+    """Optional description of the MCP server, used to provide more context."""
+
+    server_url: str
+    """The URL for the MCP server.
+
+    One of `server_url` or `connector_id` must be provided.
+    """
+
+
+class CodeInterpreterContainerCodeInterpreterToolAuto(TypedDict, total=False):
+    type: Required[Literal["auto"]]
+    """Always `auto`."""
+
+    file_ids: SequenceNotStr[str]
+    """An optional list of uploaded files to make available to your code."""
+
+
+CodeInterpreterContainer: TypeAlias = Union[str, CodeInterpreterContainerCodeInterpreterToolAuto]
+
+
+class CodeInterpreter(TypedDict, total=False):
+    container: Required[CodeInterpreterContainer]
+    """The code interpreter container.
+
+    Can be a container ID or an object that specifies uploaded file IDs to make
+    available to your code.
+    """
+
+    type: Required[Literal["code_interpreter"]]
+    """The type of the code interpreter tool. Always `code_interpreter`."""
+
+
+class ImageGenerationInputImageMask(TypedDict, total=False):
+    file_id: str
+    """File ID for the mask image."""
+
+    image_url: str
+    """Base64-encoded mask image."""
+
+
+class ImageGeneration(TypedDict, total=False):
+    type: Required[Literal["image_generation"]]
+    """The type of the image generation tool. Always `image_generation`."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """Background type for the generated image.
+
+    One of `transparent`, `opaque`, or `auto`. Default: `auto`.
+    """
+
+    input_fidelity: Optional[Literal["high", "low"]]
+    """
+    Control how much effort the model will exert to match the style and features,
+    especially facial features, of input images. This parameter is only supported
+    for `gpt-image-1`. Unsupported for `gpt-image-1-mini`. Supports `high` and
+    `low`. Defaults to `low`.
+    """
+
+    input_image_mask: ImageGenerationInputImageMask
+    """Optional mask for inpainting.
+
+    Contains `image_url` (string, optional) and `file_id` (string, optional).
+    """
+
+    model: Literal["gpt-image-1", "gpt-image-1-mini"]
+    """The image generation model to use. Default: `gpt-image-1`."""
+
+    moderation: Literal["auto", "low"]
+    """Moderation level for the generated image. Default: `auto`."""
+
+    output_compression: int
+    """Compression level for the output image. Default: 100."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format of the generated image.
+
+    One of `png`, `webp`, or `jpeg`. Default: `png`.
+    """
+
+    partial_images: int
+    """
+    Number of partial images to generate in streaming mode, from 0 (default value)
+    to 3.
+    """
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality of the generated image.
+
+    One of `low`, `medium`, `high`, or `auto`. Default: `auto`.
+    """
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the generated image.
+
+    One of `1024x1024`, `1024x1536`, `1536x1024`, or `auto`. Default: `auto`.
+    """
+
+
+class LocalShell(TypedDict, total=False):
+    type: Required[Literal["local_shell"]]
+    """The type of the local shell tool. Always `local_shell`."""
+
+
+class CustomFormatText(TypedDict, total=False):
+    type: Required[Literal["text"]]
+    """Unconstrained text format. Always `text`."""
+
+
+class CustomFormatGrammar(TypedDict, total=False):
+    definition: Required[str]
+    """The grammar definition."""
+
+    syntax: Required[Literal["lark", "regex"]]
+    """The syntax of the grammar definition. One of `lark` or `regex`."""
+
+    type: Required[Literal["grammar"]]
+    """Grammar format. Always `grammar`."""
+
+
+CustomFormat: TypeAlias = Union[CustomFormatText, CustomFormatGrammar]
+
+
+class Custom(TypedDict, total=False):
+    name: Required[str]
+    """The name of the custom tool, used to identify it in tool calls."""
+
+    type: Required[Literal["custom"]]
+    """The type of the custom tool. Always `custom`."""
+
+    description: str
+    """Optional description of the custom tool, used to provide more context."""
+
+    format: CustomFormat
+    """The input format for the custom tool. Default is unconstrained text."""
+
+
+class WebSearchPreviewToolUserLocation(TypedDict, total=False):
+    type: Required[Literal["approximate"]]
+    """The type of location approximation. Always `approximate`."""
+
+    city: Optional[str]
+    """Free text input for the city of the user, e.g. `San Francisco`."""
+
+    country: Optional[str]
+    """
+    The two-letter [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1) of
+    the user, e.g. `US`.
+    """
+
+    region: Optional[str]
+    """Free text input for the region of the user, e.g. `California`."""
+
+    timezone: Optional[str]
+    """
+    The [IANA timezone](https://timeapi.io/documentation/iana-timezones) of the
+    user, e.g. `America/Los_Angeles`.
+    """
+
+
+class WebSearchPreviewTool(TypedDict, total=False):
+    type: Required[Literal["web_search_preview", "web_search_preview_2025_03_11"]]
+    """The type of the web search tool.
+
+    One of `web_search_preview` or `web_search_preview_2025_03_11`.
+    """
+
+    search_context_size: Literal["low", "medium", "high"]
+    """High level guidance for the amount of context window space to use for the
+    search.
+
+    One of `low`, `medium`, or `high`. `medium` is the default.
+    """
+
+    user_location: Optional[WebSearchPreviewToolUserLocation]
+    """The user's location."""
+
+
+ResponseToolParam: TypeAlias = Union[
+    Function,
+    FileSearch,
+    ComputerUsePreview,
+    WebSearchTool,
+    Mcp,
+    CodeInterpreter,
+    ImageGeneration,
+    LocalShell,
+    Custom,
+    WebSearchPreviewTool,
+]

agentlin_client/types/text_response_format_configuration.py

@@ -0,0 +1,59 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._utils import PropertyInfo
+from .._models import BaseModel
+
+__all__ = ["TextResponseFormatConfiguration", "Text", "JsonSchema", "JsonObject"]
+
+
+class Text(BaseModel):
+    type: Literal["text"]
+    """The type of response format being defined. Always `text`."""
+
+
+class JsonSchema(BaseModel):
+    name: str
+    """The name of the response format.
+
+    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length
+    of 64.
+    """
+
+    schema_: Dict[str, object] = FieldInfo(alias="schema")
+    """
+    The schema for the response format, described as a JSON Schema object. Learn how
+    to build JSON schemas [here](https://json-schema.org/).
+    """
+
+    type: Literal["json_schema"]
+    """The type of response format being defined. Always `json_schema`."""
+
+    description: Optional[str] = None
+    """
+    A description of what the response format is for, used by the model to determine
+    how to respond in the format.
+    """
+
+    strict: Optional[bool] = None
+    """
+    Whether to enable strict schema adherence when generating the output. If set to
+    true, the model will always follow the exact schema defined in the `schema`
+    field. Only a subset of JSON Schema is supported when `strict` is `true`. To
+    learn more, read the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+    """
+
+
+class JsonObject(BaseModel):
+    type: Literal["json_object"]
+    """The type of response format being defined. Always `json_object`."""
+
+
+TextResponseFormatConfiguration: TypeAlias = Annotated[
+    Union[Text, JsonSchema, JsonObject], PropertyInfo(discriminator="type")
+]

agentlin_client/types/text_response_format_configuration_param.py

@@ -0,0 +1,54 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["TextResponseFormatConfigurationParam", "Text", "JsonSchema", "JsonObject"]
+
+
+class Text(TypedDict, total=False):
+    type: Required[Literal["text"]]
+    """The type of response format being defined. Always `text`."""
+
+
+class JsonSchema(TypedDict, total=False):
+    name: Required[str]
+    """The name of the response format.
+
+    Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length
+    of 64.
+    """
+
+    schema: Required[Dict[str, object]]
+    """
+    The schema for the response format, described as a JSON Schema object. Learn how
+    to build JSON schemas [here](https://json-schema.org/).
+    """
+
+    type: Required[Literal["json_schema"]]
+    """The type of response format being defined. Always `json_schema`."""
+
+    description: str
+    """
+    A description of what the response format is for, used by the model to determine
+    how to respond in the format.
+    """
+
+    strict: Optional[bool]
+    """
+    Whether to enable strict schema adherence when generating the output. If set to
+    true, the model will always follow the exact schema defined in the `schema`
+    field. Only a subset of JSON Schema is supported when `strict` is `true`. To
+    learn more, read the
+    [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+    """
+
+
+class JsonObject(TypedDict, total=False):
+    type: Required[Literal["json_object"]]
+    """The type of response format being defined. Always `json_object`."""
+
+
+TextResponseFormatConfigurationParam: TypeAlias = Union[Text, JsonSchema, JsonObject]