agentlin-client 0.1.0__py3-none-any.whl

agentlin_client/types/__init__.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .response import Response as Response
+from .response_tool import ResponseTool as ResponseTool
+from .mcp_tool_filter import McpToolFilter as McpToolFilter
+from .response_properties import ResponseProperties as ResponseProperties
+from .response_tool_param import ResponseToolParam as ResponseToolParam
+from .mcp_tool_filter_param import McpToolFilterParam as McpToolFilterParam
+from .response_create_params import ResponseCreateParams as ResponseCreateParams
+from .response_retrieve_params import ResponseRetrieveParams as ResponseRetrieveParams
+from .conversation_create_params import ConversationCreateParams as ConversationCreateParams
+from .conversation_update_params import ConversationUpdateParams as ConversationUpdateParams
+from .conversation_delete_response import ConversationDeleteResponse as ConversationDeleteResponse
+from .response_list_input_items_params import ResponseListInputItemsParams as ResponseListInputItemsParams
+from .model_response_properties_standard import ModelResponsePropertiesStandard as ModelResponsePropertiesStandard
+from .response_list_input_items_response import ResponseListInputItemsResponse as ResponseListInputItemsResponse
+from .text_response_format_configuration import TextResponseFormatConfiguration as TextResponseFormatConfiguration
+from .text_response_format_configuration_param import (
+    TextResponseFormatConfigurationParam as TextResponseFormatConfigurationParam,
+)

agentlin_client/types/conversation_create_params.py

@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Iterable, Optional
+from typing_extensions import TypedDict
+
+from .conversations.input_item_param import InputItemParam
+
+__all__ = ["ConversationCreateParams"]
+
+
+class ConversationCreateParams(TypedDict, total=False):
+    items: Optional[Iterable[InputItemParam]]
+    """Initial items to include in the conversation context.
+
+    You may add up to 20 items at a time.
+    """
+
+    metadata: Optional[Dict[str, str]]
+    """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.
+    """

agentlin_client/types/conversation_delete_response.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ConversationDeleteResponse"]
+
+
+class ConversationDeleteResponse(BaseModel):
+    id: str
+
+    deleted: bool
+
+    object: Literal["conversation.deleted"]

agentlin_client/types/conversation_update_params.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["ConversationUpdateParams"]
+
+
+class ConversationUpdateParams(TypedDict, total=False):
+    metadata: Required[Optional[Dict[str, str]]]
+    """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.
+    """

agentlin_client/types/conversations/__init__.py

@@ -0,0 +1,74 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .includable import Includable as Includable
+from .input_item import InputItem as InputItem
+from .input_content import InputContent as InputContent
+from .input_message import InputMessage as InputMessage
+from .mcp_tool_call import McpToolCall as McpToolCall
+from .mcp_list_tools import McpListTools as McpListTools
+from .output_message import OutputMessage as OutputMessage
+from .reasoning_item import ReasoningItem as ReasoningItem
+from .refusal_content import RefusalContent as RefusalContent
+from .custom_tool_call import CustomToolCall as CustomToolCall
+from .input_item_param import InputItemParam as InputItemParam
+from .item_list_params import ItemListParams as ItemListParams
+from .conversation_item import ConversationItem as ConversationItem
+from .computer_tool_call import ComputerToolCall as ComputerToolCall
+from .easy_input_message import EasyInputMessage as EasyInputMessage
+from .function_tool_call import FunctionToolCall as FunctionToolCall
+from .input_file_content import InputFileContent as InputFileContent
+from .input_text_content import InputTextContent as InputTextContent
+from .item_create_params import ItemCreateParams as ItemCreateParams
+from .image_gen_tool_call import ImageGenToolCall as ImageGenToolCall
+from .input_content_param import InputContentParam as InputContentParam
+from .input_image_content import InputImageContent as InputImageContent
+from .input_message_param import InputMessageParam as InputMessageParam
+from .mcp_tool_call_param import McpToolCallParam as McpToolCallParam
+from .output_text_content import OutputTextContent as OutputTextContent
+from .item_retrieve_params import ItemRetrieveParams as ItemRetrieveParams
+from .mcp_approval_request import McpApprovalRequest as McpApprovalRequest
+from .mcp_list_tools_param import McpListToolsParam as McpListToolsParam
+from .output_message_param import OutputMessageParam as OutputMessageParam
+from .reasoning_item_param import ReasoningItemParam as ReasoningItemParam
+from .web_search_tool_call import WebSearchToolCall as WebSearchToolCall
+from .conversation_resource import ConversationResource as ConversationResource
+from .file_search_tool_call import FileSearchToolCall as FileSearchToolCall
+from .local_shell_tool_call import LocalShellToolCall as LocalShellToolCall
+from .refusal_content_param import RefusalContentParam as RefusalContentParam
+from .conversation_item_list import ConversationItemList as ConversationItemList
+from .custom_tool_call_param import CustomToolCallParam as CustomToolCallParam
+from .reasoning_text_content import ReasoningTextContent as ReasoningTextContent
+from .custom_tool_call_output import CustomToolCallOutput as CustomToolCallOutput
+from .computer_tool_call_param import ComputerToolCallParam as ComputerToolCallParam
+from .easy_input_message_param import EasyInputMessageParam as EasyInputMessageParam
+from .function_tool_call_param import FunctionToolCallParam as FunctionToolCallParam
+from .input_file_content_param import InputFileContentParam as InputFileContentParam
+from .input_text_content_param import InputTextContentParam as InputTextContentParam
+from .computer_screenshot_image import ComputerScreenshotImage as ComputerScreenshotImage
+from .function_call_item_status import FunctionCallItemStatus as FunctionCallItemStatus
+from .image_gen_tool_call_param import ImageGenToolCallParam as ImageGenToolCallParam
+from .input_image_content_param import InputImageContentParam as InputImageContentParam
+from .output_text_content_param import OutputTextContentParam as OutputTextContentParam
+from .code_interpreter_tool_call import CodeInterpreterToolCall as CodeInterpreterToolCall
+from .mcp_approval_request_param import McpApprovalRequestParam as McpApprovalRequestParam
+from .web_search_tool_call_param import WebSearchToolCallParam as WebSearchToolCallParam
+from .file_search_tool_call_param import FileSearchToolCallParam as FileSearchToolCallParam
+from .function_tool_call_resource import FunctionToolCallResource as FunctionToolCallResource
+from .local_shell_tool_call_param import LocalShellToolCallParam as LocalShellToolCallParam
+from .local_shell_tool_call_output import LocalShellToolCallOutput as LocalShellToolCallOutput
+from .reasoning_text_content_param import ReasoningTextContentParam as ReasoningTextContentParam
+from .custom_tool_call_output_param import CustomToolCallOutputParam as CustomToolCallOutputParam
+from .mcp_approval_response_resource import McpApprovalResponseResource as McpApprovalResponseResource
+from .computer_screenshot_image_param import ComputerScreenshotImageParam as ComputerScreenshotImageParam
+from .computer_tool_call_safety_check import ComputerToolCallSafetyCheck as ComputerToolCallSafetyCheck
+from .code_interpreter_tool_call_param import CodeInterpreterToolCallParam as CodeInterpreterToolCallParam
+from .computer_tool_call_output_resource import ComputerToolCallOutputResource as ComputerToolCallOutputResource
+from .function_tool_call_output_resource import FunctionToolCallOutputResource as FunctionToolCallOutputResource
+from .local_shell_tool_call_output_param import LocalShellToolCallOutputParam as LocalShellToolCallOutputParam
+from .function_and_custom_tool_call_output import FunctionAndCustomToolCallOutput as FunctionAndCustomToolCallOutput
+from .computer_tool_call_safety_check_param import ComputerToolCallSafetyCheckParam as ComputerToolCallSafetyCheckParam
+from .function_and_custom_tool_call_output_param import (
+    FunctionAndCustomToolCallOutputParam as FunctionAndCustomToolCallOutputParam,
+)

agentlin_client/types/conversations/code_interpreter_tool_call.py

@@ -0,0 +1,55 @@
+# 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
+
+__all__ = ["CodeInterpreterToolCall", "Output", "OutputLogs", "OutputImage"]
+
+
+class OutputLogs(BaseModel):
+    logs: str
+    """The logs output from the code interpreter."""
+
+    type: Literal["logs"]
+    """The type of the output. Always 'logs'."""
+
+
+class OutputImage(BaseModel):
+    type: Literal["image"]
+    """The type of the output. Always 'image'."""
+
+    url: str
+    """The URL of the image output from the code interpreter."""
+
+
+Output: TypeAlias = Annotated[Union[OutputLogs, OutputImage], PropertyInfo(discriminator="type")]
+
+
+class CodeInterpreterToolCall(BaseModel):
+    id: str
+    """The unique ID of the code interpreter tool call."""
+
+    code: Optional[str] = None
+    """The code to run, or null if not available."""
+
+    container_id: str
+    """The ID of the container used to run the code."""
+
+    outputs: Optional[List[Output]] = None
+    """
+    The outputs generated by the code interpreter, such as logs or images. Can be
+    null if no outputs are available.
+    """
+
+    status: Literal["in_progress", "completed", "incomplete", "interpreting", "failed"]
+    """The status of the code interpreter tool call.
+
+    Valid values are `in_progress`, `completed`, `incomplete`, `interpreting`, and
+    `failed`.
+    """
+
+    type: Literal["code_interpreter_call"]
+    """The type of the code interpreter tool call. Always `code_interpreter_call`."""

agentlin_client/types/conversations/code_interpreter_tool_call_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 Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+__all__ = ["CodeInterpreterToolCallParam", "Output", "OutputLogs", "OutputImage"]
+
+
+class OutputLogs(TypedDict, total=False):
+    logs: Required[str]
+    """The logs output from the code interpreter."""
+
+    type: Required[Literal["logs"]]
+    """The type of the output. Always 'logs'."""
+
+
+class OutputImage(TypedDict, total=False):
+    type: Required[Literal["image"]]
+    """The type of the output. Always 'image'."""
+
+    url: Required[str]
+    """The URL of the image output from the code interpreter."""
+
+
+Output: TypeAlias = Union[OutputLogs, OutputImage]
+
+
+class CodeInterpreterToolCallParam(TypedDict, total=False):
+    id: Required[str]
+    """The unique ID of the code interpreter tool call."""
+
+    code: Required[Optional[str]]
+    """The code to run, or null if not available."""
+
+    container_id: Required[str]
+    """The ID of the container used to run the code."""
+
+    outputs: Required[Optional[Iterable[Output]]]
+    """
+    The outputs generated by the code interpreter, such as logs or images. Can be
+    null if no outputs are available.
+    """
+
+    status: Required[Literal["in_progress", "completed", "incomplete", "interpreting", "failed"]]
+    """The status of the code interpreter tool call.
+
+    Valid values are `in_progress`, `completed`, `incomplete`, `interpreting`, and
+    `failed`.
+    """
+
+    type: Required[Literal["code_interpreter_call"]]
+    """The type of the code interpreter tool call. Always `code_interpreter_call`."""

agentlin_client/types/conversations/computer_screenshot_image.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ComputerScreenshotImage"]
+
+
+class ComputerScreenshotImage(BaseModel):
+    type: Literal["computer_screenshot"]
+    """Specifies the event type.
+
+    For a computer screenshot, this property is always set to `computer_screenshot`.
+    """
+
+    file_id: Optional[str] = None
+    """The identifier of an uploaded file that contains the screenshot."""
+
+    image_url: Optional[str] = None
+    """The URL of the screenshot image."""

agentlin_client/types/conversations/computer_screenshot_image_param.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ComputerScreenshotImageParam"]
+
+
+class ComputerScreenshotImageParam(TypedDict, total=False):
+    type: Required[Literal["computer_screenshot"]]
+    """Specifies the event type.
+
+    For a computer screenshot, this property is always set to `computer_screenshot`.
+    """
+
+    file_id: str
+    """The identifier of an uploaded file that contains the screenshot."""
+
+    image_url: str
+    """The URL of the screenshot image."""

agentlin_client/types/conversations/computer_tool_call.py

@@ -0,0 +1,201 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .computer_tool_call_safety_check import ComputerToolCallSafetyCheck
+
+__all__ = [
+    "ComputerToolCall",
+    "Action",
+    "ActionClick",
+    "ActionDoubleClick",
+    "ActionDrag",
+    "ActionDragPath",
+    "ActionKeypress",
+    "ActionMove",
+    "ActionScreenshot",
+    "ActionScroll",
+    "ActionType",
+    "ActionWait",
+]
+
+
+class ActionClick(BaseModel):
+    button: Literal["left", "right", "wheel", "back", "forward"]
+    """Indicates which mouse button was pressed during the click.
+
+    One of `left`, `right`, `wheel`, `back`, or `forward`.
+    """
+
+    type: Literal["click"]
+    """Specifies the event type.
+
+    For a click action, this property is always set to `click`.
+    """
+
+    x: int
+    """The x-coordinate where the click occurred."""
+
+    y: int
+    """The y-coordinate where the click occurred."""
+
+
+class ActionDoubleClick(BaseModel):
+    type: Literal["double_click"]
+    """Specifies the event type.
+
+    For a double click action, this property is always set to `double_click`.
+    """
+
+    x: int
+    """The x-coordinate where the double click occurred."""
+
+    y: int
+    """The y-coordinate where the double click occurred."""
+
+
+class ActionDragPath(BaseModel):
+    x: int
+    """The x-coordinate."""
+
+    y: int
+    """The y-coordinate."""
+
+
+class ActionDrag(BaseModel):
+    path: List[ActionDragPath]
+    """An array of coordinates representing the path of the drag action.
+
+    Coordinates will appear as an array of objects, eg
+
+    ```
+    [
+      { x: 100, y: 200 },
+      { x: 200, y: 300 }
+    ]
+    ```
+    """
+
+    type: Literal["drag"]
+    """Specifies the event type.
+
+    For a drag action, this property is always set to `drag`.
+    """
+
+
+class ActionKeypress(BaseModel):
+    keys: List[str]
+    """The combination of keys the model is requesting to be pressed.
+
+    This is an array of strings, each representing a key.
+    """
+
+    type: Literal["keypress"]
+    """Specifies the event type.
+
+    For a keypress action, this property is always set to `keypress`.
+    """
+
+
+class ActionMove(BaseModel):
+    type: Literal["move"]
+    """Specifies the event type.
+
+    For a move action, this property is always set to `move`.
+    """
+
+    x: int
+    """The x-coordinate to move to."""
+
+    y: int
+    """The y-coordinate to move to."""
+
+
+class ActionScreenshot(BaseModel):
+    type: Literal["screenshot"]
+    """Specifies the event type.
+
+    For a screenshot action, this property is always set to `screenshot`.
+    """
+
+
+class ActionScroll(BaseModel):
+    scroll_x: int
+    """The horizontal scroll distance."""
+
+    scroll_y: int
+    """The vertical scroll distance."""
+
+    type: Literal["scroll"]
+    """Specifies the event type.
+
+    For a scroll action, this property is always set to `scroll`.
+    """
+
+    x: int
+    """The x-coordinate where the scroll occurred."""
+
+    y: int
+    """The y-coordinate where the scroll occurred."""
+
+
+class ActionType(BaseModel):
+    text: str
+    """The text to type."""
+
+    type: Literal["type"]
+    """Specifies the event type.
+
+    For a type action, this property is always set to `type`.
+    """
+
+
+class ActionWait(BaseModel):
+    type: Literal["wait"]
+    """Specifies the event type.
+
+    For a wait action, this property is always set to `wait`.
+    """
+
+
+Action: TypeAlias = Annotated[
+    Union[
+        ActionClick,
+        ActionDoubleClick,
+        ActionDrag,
+        ActionKeypress,
+        ActionMove,
+        ActionScreenshot,
+        ActionScroll,
+        ActionType,
+        ActionWait,
+    ],
+    PropertyInfo(discriminator="type"),
+]
+
+
+class ComputerToolCall(BaseModel):
+    id: str
+    """The unique ID of the computer call."""
+
+    action: Action
+    """A click action."""
+
+    call_id: str
+    """An identifier used when responding to the tool call with output."""
+
+    pending_safety_checks: List[ComputerToolCallSafetyCheck]
+    """The pending safety checks for the computer call."""
+
+    status: Literal["in_progress", "completed", "incomplete"]
+    """The status of the item.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when items are
+    returned via API.
+    """
+
+    type: Literal["computer_call"]
+    """The type of the computer call. Always `computer_call`."""

agentlin_client/types/conversations/computer_tool_call_output_resource.py

@@ -0,0 +1,37 @@
+# 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 .computer_screenshot_image import ComputerScreenshotImage
+from .computer_tool_call_safety_check import ComputerToolCallSafetyCheck
+
+__all__ = ["ComputerToolCallOutputResource"]
+
+
+class ComputerToolCallOutputResource(BaseModel):
+    id: str
+    """The unique ID of the computer call tool output."""
+
+    call_id: str
+    """The ID of the computer tool call that produced the output."""
+
+    output: ComputerScreenshotImage
+    """A computer screenshot image used with the computer use tool."""
+
+    type: Literal["computer_call_output"]
+    """The type of the computer tool call output. Always `computer_call_output`."""
+
+    acknowledged_safety_checks: Optional[List[ComputerToolCallSafetyCheck]] = None
+    """
+    The safety checks reported by the API that have been acknowledged by the
+    developer.
+    """
+
+    status: Optional[Literal["in_progress", "completed", "incomplete"]] = None
+    """The status of the message input.
+
+    One of `in_progress`, `completed`, or `incomplete`. Populated when input items
+    are returned via API.
+    """