chatlas 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

chatlas/__init__.py

@@ -16,7 +16,7 @@ from ._perplexity import ChatPerplexity
 from ._provider import Provider
 from ._snowflake import ChatSnowflake
 from ._tokens import token_usage
-from ._tools import Tool
+from ._tools import Tool, ToolRejectError
 from ._turn import Turn
 
 try:
@@ -51,6 +51,7 @@ __all__ = (
     "Provider",
     "token_usage",
     "Tool",
+    "ToolRejectError",
     "Turn",
     "types",
 )

chatlas/_anthropic.py

@@ -451,10 +451,7 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
     @staticmethod
     def _as_content_block(content: Content) -> "ContentBlockParam":
         if isinstance(content, ContentText):
-            text = content.text
-            if text == "" or text.isspace():
-                text = "[empty string]"
-            return {"type": "text", "text": text}
+            return {"text": content.text, "type": "text"}
         elif isinstance(content, ContentJson):
             return {"text": "<structured data/>", "type": "text"}
         elif isinstance(content, ContentPDF):

chatlas/_callbacks.py

@@ -0,0 +1,56 @@
+from collections import OrderedDict
+from typing import Any, Callable
+
+from ._utils import is_async_callable
+
+
+class CallbackManager:
+    def __init__(self) -> None:
+        self._callbacks: dict[str, Callable[..., Any]] = OrderedDict()
+        self._id: int = 1
+
+    def add(self, callback: Callable[..., Any]) -> Callable[[], None]:
+        callback_id = self._next_id()
+        self._callbacks[callback_id] = callback
+
+        def _rm_callback() -> None:
+            self._callbacks.pop(callback_id, None)
+
+        return _rm_callback
+
+    def invoke(self, *args: Any, **kwargs: Any) -> None:
+        if not self._callbacks:
+            return
+
+        # Invoke in reverse insertion order
+        for callback_id in reversed(list(self._callbacks.keys())):
+            callback = self._callbacks[callback_id]
+            if is_async_callable(callback):
+                raise RuntimeError(
+                    "Can't use async callbacks with `.chat()`/`.stream()`."
+                    "Async callbacks can only be used with `.chat_async()`/`.stream_async()`."
+                )
+            callback(*args, **kwargs)
+
+    async def invoke_async(self, *args: Any, **kwargs: Any) -> None:
+        if not self._callbacks:
+            return
+
+        # Invoke in reverse insertion order
+        for callback_id in reversed(list(self._callbacks.keys())):
+            callback = self._callbacks[callback_id]
+            if is_async_callable(callback):
+                await callback(*args, **kwargs)
+            else:
+                callback(*args, **kwargs)
+
+    def count(self) -> int:
+        return len(self._callbacks)
+
+    def get_callbacks(self) -> list[Callable[..., Any]]:
+        return list(self._callbacks.values())
+
+    def _next_id(self) -> str:
+        current_id = self._id
+        self._id += 1
+        return str(current_id)

chatlas/_chat.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 import inspect
 import os
 import sys
@@ -25,6 +26,7 @@ from typing import (
 
 from pydantic import BaseModel
 
+from ._callbacks import CallbackManager
 from ._content import (
     Content,
     ContentJson,
@@ -41,7 +43,7 @@ from ._display import (
 )
 from ._logging import log_tool_error
 from ._provider import Provider
-from ._tools import Tool
+from ._tools import Tool, ToolRejectError
 from ._turn import Turn, user_turn
 from ._typing_extensions import TypedDict
 from ._utils import html_escape, wrap_async
@@ -95,6 +97,8 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         self.provider = provider
         self._turns: list[Turn] = list(turns or [])
         self._tools: dict[str, Tool] = {}
+        self._on_tool_request_callbacks = CallbackManager()
+        self._on_tool_result_callbacks = CallbackManager()
         self._current_display: Optional[MarkdownDisplay] = None
         self._echo_options: EchoDisplayOptions = {
             "rich_markdown": {},
@@ -631,31 +635,18 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
     def stream(
         self,
         *args: Content | str,
-    ) -> Generator[str, None, None]: ...
-
-    @overload
-    def stream(
-        self,
-        *args: Content | str,
-        echo: EchoOptions,
-    ) -> Generator[str, None, None]: ...
-
-    @overload
-    def stream(
-        self,
-        *args: Content | str,
-        echo: EchoOptions,
         content: Literal["text"],
-        kwargs: Optional[SubmitInputArgsT],
+        echo: EchoOptions = "none",
+        kwargs: Optional[SubmitInputArgsT] = None,
     ) -> Generator[str, None, None]: ...
 
     @overload
     def stream(
         self,
         *args: Content | str,
-        echo: EchoOptions,
         content: Literal["all"],
-        kwargs: Optional[SubmitInputArgsT],
+        echo: EchoOptions = "none",
+        kwargs: Optional[SubmitInputArgsT] = None,
     ) -> Generator[str | ContentToolRequest | ContentToolResult, None, None]: ...
 
     def stream(
@@ -712,31 +703,18 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
     async def stream_async(
         self,
         *args: Content | str,
-    ) -> AsyncGenerator[str, None]: ...
-
-    @overload
-    async def stream_async(
-        self,
-        *args: Content | str,
-        echo: EchoOptions,
-    ) -> AsyncGenerator[str, None]: ...
-
-    @overload
-    async def stream_async(
-        self,
-        *args: Content | str,
-        echo: EchoOptions,
         content: Literal["text"],
-        kwargs: Optional[SubmitInputArgsT],
+        echo: EchoOptions = "none",
+        kwargs: Optional[SubmitInputArgsT] = None,
     ) -> AsyncGenerator[str, None]: ...
 
     @overload
     async def stream_async(
         self,
         *args: Content | str,
-        echo: EchoOptions,
         content: Literal["all"],
-        kwargs: Optional[SubmitInputArgsT],
+        echo: EchoOptions = "none",
+        kwargs: Optional[SubmitInputArgsT] = None,
     ) -> AsyncGenerator[str | ContentToolRequest | ContentToolResult, None]: ...
 
     async def stream_async(
@@ -987,6 +965,53 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         tool = Tool(func, model=model)
         self._tools[tool.name] = tool
 
+    def on_tool_request(self, callback: Callable[[ContentToolRequest], None]):
+        """
+        Register a callback for a tool request event.
+
+        A tool request event occurs when the assistant requests a tool to be
+        called on its behalf. Before invoking the tool, `on_tool_request`
+        handlers are called with the relevant `ContentToolRequest` object. This
+        is useful if you want to handle tool requests in a custom way, such as
+        requiring logging them or requiring user approval before invoking the
+        tool
+
+        Parameters
+        ----------
+        callback
+            A function to be called when a tool request event occurs.
+            This function must have a single argument, which will be the
+            tool request (i.e., a `ContentToolRequest` object).
+
+        Returns
+        -------
+        A callable that can be used to remove the callback later.
+        """
+        return self._on_tool_request_callbacks.add(callback)
+
+    def on_tool_result(self, callback: Callable[[ContentToolResult], None]):
+        """
+        Register a callback for a tool result event.
+
+        A tool result event occurs when a tool has been invoked and the
+        result is ready to be provided to the assistant. After the tool
+        has been invoked, `on_tool_result` handlers are called with the
+        relevant `ContentToolResult` object. This is useful if you want to
+        handle tool results in a custom way such as logging them.
+
+        Parameters
+        ----------
+        callback
+            A function to be called when a tool result event occurs.
+            This function must have a single argument, which will be the
+            tool result (i.e., a `ContentToolResult` object).
+
+        Returns
+        -------
+        A callable that can be used to remove the callback later.
+        """
+        return self._on_tool_result_callbacks.add(callback)
+
     @property
     def current_display(self) -> Optional[MarkdownDisplay]:
         """
@@ -1417,28 +1442,43 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             e = RuntimeError(f"Unknown tool: {x.name}")
             return ContentToolResult(value=None, error=e, request=x)
 
-        args = x.arguments
-
+        # First, invoke the request callbacks. If a ToolRejectError is raised,
+        # treat it like a tool failure (i.e., gracefully handle it).
+        result: ContentToolResult | None = None
         try:
-            if isinstance(args, dict):
-                result = func(**args)
-            else:
-                result = func(args)
+            self._on_tool_request_callbacks.invoke(x)
+        except ToolRejectError as e:
+            result = ContentToolResult(value=None, error=e, request=x)
+
+        # Invoke the tool (if it hasn't been rejected).
+        if result is None:
+            try:
+                if isinstance(x.arguments, dict):
+                    res = func(**x.arguments)
+                else:
+                    res = func(x.arguments)
+
+                if isinstance(res, ContentToolResult):
+                    result = res
+                else:
+                    result = ContentToolResult(value=res)
 
-            if not isinstance(result, ContentToolResult):
-                result = ContentToolResult(value=result)
+                result.request = x
+            except Exception as e:
+                result = ContentToolResult(value=None, error=e, request=x)
 
-            result.request = x
-            return result
-        except Exception as e:
+        # If we've captured an error, notify and log it.
+        if result.error:
             warnings.warn(
                 f"Calling tool '{x.name}' led to an error.",
                 ToolFailureWarning,
                 stacklevel=2,
             )
             traceback.print_exc()
-            log_tool_error(x.name, str(args), e)
-            return ContentToolResult(value=None, error=e, request=x)
+            log_tool_error(x.name, str(x.arguments), result.error)
+
+        self._on_tool_result_callbacks.invoke(result)
+        return result
 
     async def _invoke_tool_async(self, x: ContentToolRequest) -> ContentToolResult:
         tool_def = self._tools.get(x.name, None)
@@ -1453,28 +1493,43 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             e = RuntimeError(f"Unknown tool: {x.name}")
             return ContentToolResult(value=None, error=e, request=x)
 
-        args = x.arguments
-
+        # First, invoke the request callbacks. If a ToolRejectError is raised,
+        # treat it like a tool failure (i.e., gracefully handle it).
+        result: ContentToolResult | None = None
         try:
-            if isinstance(args, dict):
-                result = await func(**args)
-            else:
-                result = await func(args)
+            await self._on_tool_request_callbacks.invoke_async(x)
+        except ToolRejectError as e:
+            result = ContentToolResult(value=None, error=e, request=x)
+
+        # Invoke the tool (if it hasn't been rejected).
+        if result is None:
+            try:
+                if isinstance(x.arguments, dict):
+                    res = await func(**x.arguments)
+                else:
+                    res = await func(x.arguments)
+
+                if isinstance(res, ContentToolResult):
+                    result = res
+                else:
+                    result = ContentToolResult(value=res)
 
-            if not isinstance(result, ContentToolResult):
-                result = ContentToolResult(value=result)
+                result.request = x
+            except Exception as e:
+                result = ContentToolResult(value=None, error=e, request=x)
 
-            result.request = x
-            return result
-        except Exception as e:
+        # If we've captured an error, notify and log it.
+        if result.error:
             warnings.warn(
                 f"Calling tool '{x.name}' led to an error.",
                 ToolFailureWarning,
                 stacklevel=2,
             )
             traceback.print_exc()
-            log_tool_error(x.name, str(args), e)
-            return ContentToolResult(value=None, error=e, request=x)
+            log_tool_error(x.name, str(x.arguments), result.error)
+
+        await self._on_tool_result_callbacks.invoke_async(result)
+        return result
 
     def _markdown_display(self, echo: EchoOptions) -> ChatMarkdownDisplay:
         """
@@ -1545,6 +1600,21 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             res += "\n" + turn.__repr__(indent=2)
         return res + "\n"
 
+    def __deepcopy__(self, memo):
+        result = self.__class__.__new__(self.__class__)
+
+        # Avoid recursive references
+        memo[id(self)] = result
+
+        # Copy all attributes except the problematic provider attribute
+        for key, value in self.__dict__.items():
+            if key != "provider":
+                setattr(result, key, copy.deepcopy(value, memo))
+            else:
+                setattr(result, key, value)
+
+        return result
+
 
 class ChatResponse:
     """

chatlas/_content.py

@@ -60,6 +60,12 @@ class ContentText(Content):
     text: str
     content_type: ContentTypeEnum = "text"
 
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+
+        if self.text == "" or self.text.isspace():
+            self.text = "[empty string]"
+
     def __str__(self):
         return self.text
 

chatlas/_databricks.py

@@ -85,7 +85,7 @@ def ChatDatabricks(
         A chat object that retains the state of the conversation.
     """
     if model is None:
-        model = log_model_default("databricks-dbrx-instruct")
+        model = log_model_default("databricks-claude-3-7-sonnet")
 
     return Chat(
         provider=DatabricksProvider(

chatlas/_logging.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import warnings
+from typing import Literal
 
 from rich.logging import RichHandler
 
@@ -12,15 +13,38 @@ def _rich_handler() -> RichHandler:
     return handler
 
 
-logger = logging.getLogger("chatlas")
-
-if os.environ.get("CHATLAS_LOG") == "info":
+def setup_logger(x: str, level: Literal["debug", "info"]) -> logging.Logger:
+    logger = logging.getLogger(x)
+    if level == "debug":
+        logger.setLevel(logging.DEBUG)
+    elif level == "info":
+        logger.setLevel(logging.INFO)
     # By adding a RichHandler to chatlas' logger, we can guarantee that they
     # never get dropped, even if the root logger's handlers are not
     # RichHandlers.
-    logger.setLevel(logging.INFO)
-    logger.addHandler(_rich_handler())
+    if not any(isinstance(h, RichHandler) for h in logger.handlers):
+        logger.addHandler(_rich_handler())
     logger.propagate = False
+    return logger
+
+
+logger = logging.getLogger("chatlas")
+log_level = os.environ.get("CHATLAS_LOG")
+if log_level:
+    if log_level != "debug" and log_level != "info":
+        warnings.warn(
+            f"CHATLAS_LOG is set to '{log_level}', but the log level must "
+            "be one of 'debug' or 'info'. Defaulting to 'info'.",
+        )
+        log_level = "info"
+
+    # Manually setup the logger for each dependency we care about. This way, we
+    # can ensure that the logs won't get dropped when a rich display is activate
+    logger = setup_logger("chatlas", log_level)
+    openai_logger = setup_logger("openai", log_level)
+    anthropic_logger = setup_logger("anthropic", log_level)
+    google_logger = setup_logger("google_genai.models", log_level)
+    httpx_logger = setup_logger("httpx", log_level)
 
     # Add a RichHandler to the root logger if there are no handlers. Note that
     # if chatlas is imported before other libraries that set up logging, (like

chatlas/_snowflake.py

@@ -1,32 +1,60 @@
-import asyncio
-import json
-from typing import TYPE_CHECKING, Iterable, Literal, Optional, TypedDict, cast, overload
-
+from typing import (
+    TYPE_CHECKING,
+    Generator,
+    Literal,
+    Optional,
+    TypedDict,
+    Union,
+    overload,
+)
+
+import orjson
 from pydantic import BaseModel
 
 from ._chat import Chat
-from ._content import Content, ContentJson, ContentText
+from ._content import (
+    Content,
+    ContentJson,
+    ContentText,
+    ContentToolRequest,
+    ContentToolResult,
+)
 from ._logging import log_model_default
 from ._provider import Provider
+from ._tokens import tokens_log
 from ._tools import Tool, basemodel_to_param_schema
 from ._turn import Turn, normalize_turns
-from ._utils import drop_none, wrap_async_iterable
+from ._utils import drop_none
 
 if TYPE_CHECKING:
-    from snowflake.snowpark import Column
+    import snowflake.core.cortex.inference_service._generated.models as models
+    from snowflake.core.rest import Event, SSEClient
+
+    Completion = models.NonStreamingCompleteResponse
+    CompletionChunk = models.StreamingCompleteResponseDataEvent
+
+    # Manually constructed TypedDict equivalent of models.CompleteRequest
+    class CompleteRequest(TypedDict, total=False):
+        """
+        CompleteRequest parameters for Snowflake Cortex LLMs.
+
+        See `snowflake.core.cortex.inference_service.CompleteRequest` for more details.
+        """
+
+        temperature: Union[float, int]
+        """Temperature controls the amount of randomness used in response generation. A higher temperature corresponds to more randomness."""
 
-    # Types inferred from the return type of the `snowflake.cortex.complete` function
-    Completion = str | Column
-    CompletionChunk = str
+        top_p: Union[float, int]
+        """Threshold probability for nucleus sampling. A higher top-p value increases the diversity of tokens that the model considers, while a lower value results in more predictable output."""
 
-    from .types.snowflake import SubmitInputArgs
+        max_tokens: int
+        """The maximum number of output tokens to produce. The default value is model-dependent."""
 
+        guardrails: models.GuardrailsConfig
+        """Controls whether guardrails are enabled."""
 
-# The main prompt input type for Snowflake
-# This was copy-pasted from `snowflake.cortex._complete.ConversationMessage`
-class ConversationMessage(TypedDict):
-    role: str
-    content: str
+        tool_choice: models.ToolChoice
+        """Determines how tools are selected."""
 
 
 def ChatSnowflake(
@@ -41,7 +69,7 @@ def ChatSnowflake(
     private_key_file: Optional[str] = None,
     private_key_file_pwd: Optional[str] = None,
     kwargs: Optional[dict[str, "str | int"]] = None,
-) -> Chat["SubmitInputArgs", "Completion"]:
+) -> Chat["CompleteRequest", "Completion"]:
     """
     Chat with a Snowflake Cortex LLM
 
@@ -116,7 +144,7 @@ def ChatSnowflake(
     """
 
     if model is None:
-        model = log_model_default("llama3.1-70b")
+        model = log_model_default("claude-3-7-sonnet")
 
     return Chat(
         provider=SnowflakeProvider(
@@ -150,6 +178,7 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
         kwargs: Optional[dict[str, "str | int"]],
     ):
         try:
+            from snowflake.core import Root
             from snowflake.snowpark import Session
         except ImportError:
             raise ImportError(
@@ -170,7 +199,9 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
         )
 
         self._model = model
-        self._session = Session.builder.configs(configs).create()
+
+        session = Session.builder.configs(configs).create()
+        self._cortex_service = Root(session).cortex_inference_service
 
     @overload
     def chat_perform(
@@ -180,7 +211,7 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
         turns: list[Turn],
         tools: dict[str, Tool],
         data_model: Optional[type[BaseModel]] = None,
-        kwargs: Optional["SubmitInputArgs"] = None,
+        kwargs: Optional["CompleteRequest"] = None,
     ): ...
 
     @overload
@@ -191,7 +222,7 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
         turns: list[Turn],
         tools: dict[str, Tool],
         data_model: Optional[type[BaseModel]] = None,
-        kwargs: Optional["SubmitInputArgs"] = None,
+        kwargs: Optional["CompleteRequest"] = None,
     ): ...
 
     def chat_perform(
@@ -201,12 +232,25 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
         turns: list[Turn],
         tools: dict[str, Tool],
         data_model: Optional[type[BaseModel]] = None,
-        kwargs: Optional["SubmitInputArgs"] = None,
+        kwargs: Optional["CompleteRequest"] = None,
     ):
-        from snowflake.cortex import complete
+        req = self._complete_request(stream, turns, tools, data_model, kwargs)
+        client = self._cortex_service.complete(req)
+
+        try:
+            events = client.events()
+        except Exception as e:
+            data = parse_request_object(client)
+            if data is None:
+                raise e
+            return data
 
-        kwargs = self._chat_perform_args(stream, turns, tools, data_model, kwargs)
-        return complete(**kwargs)
+        if stream:
+            return generate_event_data(events)
+
+        for evt in events:
+            if evt.data:
+                return parse_event_data(evt.data, stream=False)
 
     @overload
     async def chat_perform_async(
@@ -216,7 +260,7 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
         turns: list[Turn],
         tools: dict[str, Tool],
         data_model: Optional[type[BaseModel]] = None,
-        kwargs: Optional["SubmitInputArgs"] = None,
+        kwargs: Optional["CompleteRequest"] = None,
     ): ...
 
     @overload
@@ -227,7 +271,7 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
         turns: list[Turn],
         tools: dict[str, Tool],
         data_model: Optional[type[BaseModel]] = None,
-        kwargs: Optional["SubmitInputArgs"] = None,
+        kwargs: Optional["CompleteRequest"] = None,
     ): ...
 
     async def chat_perform_async(
@@ -237,65 +281,164 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
         turns: list[Turn],
         tools: dict[str, Tool],
         data_model: Optional[type[BaseModel]] = None,
-        kwargs: Optional["SubmitInputArgs"] = None,
+        kwargs: Optional["CompleteRequest"] = None,
     ):
-        from snowflake.cortex import complete
-
-        kwargs = self._chat_perform_args(stream, turns, tools, data_model, kwargs)
+        req = self._complete_request(stream, turns, tools, data_model, kwargs)
+        res = self._cortex_service.complete_async(req)
+        # TODO: is there a way to get the SSEClient result without blocking?
+        client = res.result()
 
-        # Prevent the main thread from being blocked (Snowflake doesn't have native async support)
-        res = await asyncio.to_thread(complete, **kwargs)
+        try:
+            events = client.events()
+        except Exception as e:
+            data = parse_request_object(client)
+            if data is None:
+                raise e
+            return data
 
-        # When streaming, res is an iterable of strings, but Chat() wants an async iterable
         if stream:
-            res = wrap_async_iterable(cast(Iterable[str], res))
+            return generate_event_data_async(events)
 
-        return res
+        for evt in events:
+            if evt.data:
+                return parse_event_data(evt.data, stream=False)
 
-    def _chat_perform_args(
+    def _complete_request(
         self,
         stream: bool,
         turns: list[Turn],
         tools: dict[str, Tool],
         data_model: Optional[type[BaseModel]] = None,
-        kwargs: Optional["SubmitInputArgs"] = None,
+        kwargs: Optional["CompleteRequest"] = None,
     ):
-        kwargs_full: "SubmitInputArgs" = {
-            "stream": stream,
-            "prompt": self._as_prompt_input(turns),
-            "model": self._model,
-            "session": self._session,
-            **(kwargs or {}),
-        }
-
-        # TODO: get tools working
+        from snowflake.core.cortex.inference_service import CompleteRequest
+
+        req = CompleteRequest(
+            model=self._model,
+            messages=self._as_request_messages(turns),
+            stream=stream,
+        )
+
         if tools:
-            raise ValueError("Snowflake does not currently support tools.")
+            req.tools = req.tools or []
+            snow_tools = [self._as_snowflake_tool(tool) for tool in tools.values()]
+            req.tools.extend(snow_tools)
 
         if data_model is not None:
+            import snowflake.core.cortex.inference_service._generated.models as models
+
             params = basemodel_to_param_schema(data_model)
-            opts = kwargs_full.get("options") or {}
-            opts["response_format"] = {
-                "type": "json",
-                "schema": {
+            req.response_format = models.CompleteRequestResponseFormat(
+                type="json",
+                schema={
                     "type": "object",
                     "properties": params["properties"],
                     "required": params["required"],
                 },
-            }
-            kwargs_full["options"] = opts
+            )
 
-        return kwargs_full
+        if kwargs:
+            for k, v in kwargs.items():
+                if hasattr(req, k):
+                    setattr(req, k, v)
+                else:
+                    raise ValueError(
+                        f"Unknown parameter {k} for Snowflake CompleteRequest. "
+                        "Please check the Snowflake documentation for valid parameters."
+                    )
 
-    def stream_text(self, chunk):
-        return chunk
+        return req
 
+    def stream_text(self, chunk):
+        if not chunk.choices:
+            return None
+        delta = chunk.choices[0].delta
+        if delta is None or "content" not in delta:
+            return None
+        return delta["content"]
+
+    # Snowflake sort-of follows OpenAI/Anthropic streaming formats except they
+    # don't have the critical "index" field in the delta that the merge logic
+    # depends on (i.e., OpenAI), or official start/stop events (i.e.,
+    # Anthropic). So we have to do some janky merging here.
+    #
+    # This was done in a panic to get working asap, so don't judge :) I wouldn't
+    # be surprised if Snowflake realizes how bad this streaming format is and
+    # changes it in the future (thus probably breaking this code :( ).
     def stream_merge_chunks(self, completion, chunk):
         if completion is None:
             return chunk
-        return completion + chunk
+
+        if completion.choices is None or chunk.choices is None:
+            raise ValueError(
+                "Unexpected None for completion.choices. Please report this issue."
+            )
+
+        if completion.choices[0].delta is None or chunk.choices[0].delta is None:
+            raise ValueError(
+                "Unexpected None for completion.choices[0].delta. Please report this issue."
+            )
+
+        delta = completion.choices[0].delta
+        new_delta = chunk.choices[0].delta
+        if "content_list" not in delta or "content_list" not in new_delta:
+            raise ValueError(
+                "Expected content_list to be in completion.choices[0].delta. Please report this issue."
+            )
+
+        content_list = delta["content_list"]
+        new_content_list = new_delta["content_list"]
+        if not isinstance(content_list, list) or not isinstance(new_content_list, list):
+            raise ValueError(
+                f"Expected content_list to be a list, got {type(new_content_list)}"
+            )
+
+        if new_delta["type"] == "tool_use":
+            # Presence of "tool_use_id" indicates a new tool request; otherwise, we're
+            # expecting input parameters
+            if "tool_use_id" in new_delta:
+                del new_delta["text"]  # why is this here :eye-roll:?
+                content_list.append(new_delta)
+            elif "input" in new_delta:
+                # find most recent content with type: "tool_use" and append to that
+                for i in range(len(content_list) - 1, -1, -1):
+                    if "tool_use_id" in content_list[i]:
+                        content_list[i]["input"] = content_list[i].get("input", "")
+                        content_list[i]["input"] += new_delta["input"]
+                        break
+            else:
+                raise ValueError(
+                    f"Unexpected tool_use delta: {new_delta}. Please report this issue."
+                )
+        elif new_delta["type"] == "text":
+            text = new_delta["text"]
+            # find most recent content with type: "text" and append to that
+            for i in range(len(content_list) - 1, -1, -1):
+                if content_list[i].get("type") == "text":
+                    content_list[i]["text"] += text
+                    break
+            else:
+                # if we don't find it, just append to the end
+                # this shouldn't happen, but just in case
+                content_list.append({"type": "text", "text": text})
+        else:
+            raise ValueError(
+                f"Unexpected streaming delta type: {new_delta['type']}. Please report this issue."
+            )
+
+        completion.choices[0].delta["content_list"] = content_list
+
+        return completion
 
     def stream_turn(self, completion, has_data_model) -> Turn:
+        import snowflake.core.cortex.inference_service._generated.models as models
+
+        completion_dict = completion.model_dump()
+        delta = completion_dict["choices"][0].pop("delta")
+        completion_dict["choices"][0]["message"] = delta
+        completion = models.NonStreamingCompleteResponse.model_construct(
+            **completion_dict
+        )
         return self._as_turn(completion, has_data_model)
 
     def value_turn(self, completion, has_data_model) -> Turn:
@@ -321,24 +464,207 @@ class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChu
             "Snowflake does not currently support token counting."
         )
 
-    def _as_prompt_input(self, turns: list[Turn]) -> list["ConversationMessage"]:
-        res: list["ConversationMessage"] = []
+    def _as_request_messages(self, turns: list[Turn]):
+        from snowflake.core.cortex.inference_service import CompleteRequestMessagesInner
+
+        res: list[CompleteRequestMessagesInner] = []
         for turn in turns:
-            res.append(
-                {
-                    "role": turn.role,
-                    "content": str(turn),
-                }
+            req = CompleteRequestMessagesInner(
+                role=turn.role,
+                content=turn.text,
             )
+            for x in turn.contents:
+                if isinstance(x, ContentToolRequest):
+                    req.content_list = req.content_list or []
+                    req.content_list.append(
+                        {
+                            "type": "tool_use",
+                            "tool_use": {
+                                "tool_use_id": x.id,
+                                "name": x.name,
+                                "input": x.arguments,
+                            },
+                        }
+                    )
+                elif isinstance(x, ContentToolResult):
+                    # Snowflake does like empty content
+                    req.content = req.content or "[tool_result]"
+                    req.content_list = req.content_list or []
+                    req.content_list.append(
+                        {
+                            "type": "tool_results",
+                            "tool_results": {
+                                "tool_use_id": x.id,
+                                "name": x.name,
+                                "content": [
+                                    {"type": "text", "text": x.get_model_value()}
+                                ],
+                            },
+                        }
+                    )
+                elif isinstance(x, ContentJson):
+                    req.content = req.content or "<structured data/>"
+
+            res.append(req)
         return res
 
-    def _as_turn(self, completion, has_data_model) -> Turn:
-        completion = cast(str, completion)
+    def _as_turn(self, completion: "Completion", has_data_model: bool) -> Turn:
+        import snowflake.core.cortex.inference_service._generated.models as models
+
+        if not completion.choices:
+            return Turn("assistant", [])
+
+        choice = completion.choices[0]
+        if isinstance(choice, dict):
+            choice = models.NonStreamingCompleteResponseChoicesInner.from_dict(choice)
+
+        message = choice.message
+        if message is None:
+            return Turn("assistant", [])
+
+        contents: list[Content] = []
+        content_list = message.content_list or []
+        for content in content_list:
+            if "text" in content:
+                if has_data_model:
+                    data = orjson.loads(content["text"])
+                    contents.append(ContentJson(value=data))
+                else:
+                    contents.append(ContentText(text=content["text"]))
+            elif "tool_use_id" in content:
+                params = content.get("input", "{}")
+                try:
+                    params = orjson.loads(params)
+                except orjson.JSONDecodeError:
+                    raise ValueError(
+                        f"Failed to parse tool_use input: {params}. Please report this issue."
+                    )
+                contents.append(
+                    ContentToolRequest(
+                        name=content["name"],
+                        id=content["tool_use_id"],
+                        arguments=params,
+                    )
+                )
+
+        usage = completion.usage
+        if usage is None:
+            tokens = (0, 0)
+        else:
+            tokens = (usage.prompt_tokens or 0, usage.completion_tokens or 0)
+
+        tokens_log(self, tokens)
+
+        return Turn(
+            "assistant",
+            contents,
+            tokens=tokens,
+            # TODO: no finish_reason in Snowflake?
+            # finish_reason=completion.choices[0].finish_reason,
+            completion=completion,
+        )
+
+    # N.B. this is currently the best documentation I can find for how tool calling works
+    # https://quickstarts.snowflake.com/guide/getting-started-with-tool-use-on-cortex-and-anthropic-claude/index.html#5
+    def _as_snowflake_tool(self, tool: Tool):
+        import snowflake.core.cortex.inference_service._generated.models as models
+
+        func = tool.schema["function"]
+        params = func.get("parameters", {})
+
+        props = params.get("properties", {})
+        if not isinstance(props, dict):
+            raise ValueError(
+                f"Tool function parameters must be a dictionary, got {type(props)}"
+            )
+
+        required = params.get("required", [])
+        if not isinstance(required, list):
+            raise ValueError(
+                f"Tool function required parameters must be a list, got {type(required)}"
+            )
+
+        input_schema = models.ToolToolSpecInputSchema(
+            type="object",
+            properties=props or None,
+            required=required or None,
+        )
+
+        spec = models.ToolToolSpec(
+            type="generic",
+            name=func["name"],
+            description=func.get("description", ""),
+            input_schema=input_schema,
+        )
 
-        if has_data_model:
-            data = json.loads(completion)
-            contents = [ContentJson(value=data)]
+        return models.Tool(tool_spec=spec)
+
+
+# Yield parsed event data from the Snowflake SSEClient
+# (this is only needed for the streaming case).
+def generate_event_data(events: Generator["Event", None, None]):
+    for x in events:
+        if x.data:
+            yield parse_event_data(x.data, stream=True)
+
+
+# Same thing for the async case.
+async def generate_event_data_async(events: Generator["Event", None, None]):
+    for x in events:
+        if x.data:
+            yield parse_event_data(x.data, stream=True)
+
+
+@overload
+def parse_event_data(
+    data: str, stream: Literal[True]
+) -> "models.StreamingCompleteResponseDataEvent": ...
+
+
+@overload
+def parse_event_data(
+    data: str, stream: Literal[False]
+) -> "models.NonStreamingCompleteResponse": ...
+
+
+def parse_event_data(
+    data: str, stream: bool
+) -> "models.NonStreamingCompleteResponse | models.StreamingCompleteResponseDataEvent":
+    "Parse the (JSON) event data from Snowflake using the relevant pydantic model."
+    import snowflake.core.cortex.inference_service._generated.models as models
+
+    try:
+        if stream:
+            return models.StreamingCompleteResponseDataEvent.from_json(data)
         else:
-            contents = [ContentText(text=completion)]
+            return models.NonStreamingCompleteResponse.from_json(data)
+    except Exception:
+        raise ValueError(
+            f"Failed to parse Snowflake event data: {data}. "
+            "Please report this error here: https://github.com/posit-dev/chatlas/issues/new"
+        )
+
+
+# At the time writing, .events() flat out errors in the stream=False case since
+# the Content-Type is set to application/json;charset=utf-8, and SSEClient
+# doesn't know how to handle that.
+# https://github.com/snowflakedb/snowflake-ml-python/blob/6910e96/snowflake/cortex/_sse_client.py#L69
+#
+# So, do some janky stuff here to get the data out of the response.
+#
+# If and when snowflake fixes this, we can remove the try/except block.
+def parse_request_object(
+    client: "SSEClient",
+) -> "Optional[models.NonStreamingCompleteResponse]":
+    try:
+        import urllib3
+
+        if isinstance(client._event_source, urllib3.response.HTTPResponse):
+            return parse_event_data(
+                client._event_source.data.decode("utf-8"),
+                stream=False,
+            )
+    except Exception:
+        pass
 
-        return Turn("assistant", contents)
+    return None

chatlas/_tools.py

@@ -8,7 +8,10 @@ from pydantic import BaseModel, Field, create_model
 
 from . import _utils
 
-__all__ = ("Tool",)
+__all__ = (
+    "Tool",
+    "ToolRejectError",
+)
 
 if TYPE_CHECKING:
     from openai.types.chat import ChatCompletionToolParam
@@ -47,6 +50,61 @@ class Tool:
         self.name = self.schema["function"]["name"]
 
 
+class ToolRejectError(Exception):
+    """
+    Error to represent a tool call being rejected.
+
+    This error is meant to be raised when an end user has chosen to deny a tool
+    call. It can be raised in a tool function or in a `.on_tool_request()`
+    callback registered via a :class:`~chatlas.Chat`. When used in the callback,
+    the tool call is rejected before the tool function is invoked.
+
+    Parameters
+    ----------
+    reason
+        A string describing the reason for rejecting the tool call. This will be
+        included in the error message passed to the LLM. In addition to the
+        reason, the error message will also include "Tool call rejected." to
+        indicate that the tool call was not processed.
+
+    Raises
+    -------
+    ToolRejectError
+        An error with a message informing the LLM that the tool call was
+        rejected (and the reason why).
+
+    Examples
+    --------
+    >>> import os
+    >>> import chatlas as ctl
+    >>>
+    >>> chat = ctl.ChatOpenAI()
+    >>>
+    >>> def list_files():
+    ...     "List files in the user's current directory"
+    ...     while True:
+    ...         allow = input(
+    ...             "Would you like to allow access to your current directory? (yes/no): "
+    ...         )
+    ...         if allow.lower() == "yes":
+    ...             return os.listdir(".")
+    ...         elif allow.lower() == "no":
+    ...             raise ctl.ToolRejectError(
+    ...                 "The user has chosen to disallow the tool call."
+    ...             )
+    ...         else:
+    ...             print("Please answer with 'yes' or 'no'.")
+    >>>
+    >>> chat.register_tool(list_files)
+    >>> chat.chat("What files are available in my current directory?")
+    """
+
+    def __init__(self, reason: str = "The user has chosen to disallow the tool call."):
+        message = f"Tool call rejected. {reason}"
+        super().__init__(message)
+        self.message = message
+
+
 def func_to_schema(
     func: Callable[..., Any] | Callable[..., Awaitable[Any]],
     model: Optional[type[BaseModel]] = None,

chatlas/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.7.1'
-__version_tuple__ = version_tuple = (0, 7, 1)
+__version__ = version = '0.8.0'
+__version_tuple__ = version_tuple = (0, 8, 0)

chatlas/types/anthropic/_submit.py

@@ -29,9 +29,15 @@ class SubmitInputArgs(TypedDict, total=False):
             "claude-3-7-sonnet-20250219",
             "claude-3-5-haiku-latest",
             "claude-3-5-haiku-20241022",
+            "claude-sonnet-4-20250514",
+            "claude-sonnet-4-0",
+            "claude-4-sonnet-20250514",
             "claude-3-5-sonnet-latest",
             "claude-3-5-sonnet-20241022",
             "claude-3-5-sonnet-20240620",
+            "claude-opus-4-0",
+            "claude-opus-4-20250514",
+            "claude-4-opus-20250514",
             "claude-3-opus-latest",
             "claude-3-opus-20240229",
             "claude-3-sonnet-20240229",
@@ -41,6 +47,7 @@ class SubmitInputArgs(TypedDict, total=False):
         ],
         str,
     ]
+    service_tier: Union[Literal["auto", "standard_only"], anthropic.NotGiven]
     stop_sequences: Union[list[str], anthropic.NotGiven]
     stream: Union[Literal[False], Literal[True], anthropic.NotGiven]
     system: Union[

chatlas/types/openai/_submit.py

@@ -70,6 +70,7 @@ class SubmitInputArgs(TypedDict, total=False):
             "gpt-4o-search-preview-2025-03-11",
             "gpt-4o-mini-search-preview-2025-03-11",
             "chatgpt-4o-latest",
+            "codex-mini-latest",
             "gpt-4o-mini",
             "gpt-4o-mini-2024-07-18",
             "gpt-4-turbo",

{chatlas-0.7.1.dist-info → chatlas-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatlas
-Version: 0.7.1
+Version: 0.8.0
 Summary: A simple and consistent interface for chatting with LLMs
 Project-URL: Homepage, https://posit-dev.github.io/chatlas
 Project-URL: Documentation, https://posit-dev.github.io/chatlas
@@ -44,7 +44,7 @@ Requires-Dist: pillow; extra == 'dev'
 Requires-Dist: python-dotenv; extra == 'dev'
 Requires-Dist: ruff>=0.6.5; extra == 'dev'
 Requires-Dist: shiny; extra == 'dev'
-Requires-Dist: snowflake-ml-python; extra == 'dev'
+Requires-Dist: snowflake-ml-python>=1.8.4; extra == 'dev'
 Requires-Dist: tenacity; extra == 'dev'
 Requires-Dist: tiktoken; extra == 'dev'
 Requires-Dist: torch; (python_version <= '3.11') and extra == 'dev'

{chatlas-0.7.1.dist-info → chatlas-0.8.0.dist-info}/RECORD

@@ -1,47 +1,46 @@
-chatlas/__init__.py,sha256=5bHHZOdSM84VUD1WlUYH7vYxGiHygYEoRsQzGHHDXXk,1531
-chatlas/_anthropic.py,sha256=VAtzRcrWPVe38wBBtDapxURISF2qn2yd6wg_8VY94Lk,24994
+chatlas/__init__.py,sha256=vZpEIGNqb8pJ5QCEYjHcKuoc0HDTkuhR40sJfKdhN7s,1571
+chatlas/_anthropic.py,sha256=iF2aFS07T4I2Zlw5hI6Y-PjIBH4cG6ibOgVy12dI_6I,24885
 chatlas/_auto.py,sha256=HsAvVwpSOkI9fdC35YX8beaE2IBnWLWTzOzu0ny951o,6129
-chatlas/_chat.py,sha256=wTkXu_AmL2frIHy-JZveuY44BigkrG21_06beyD3pIw,52691
-chatlas/_content.py,sha256=VW1iKOWlzeoOjTg_TNQTj1zlmdWbDXqTjBy3fxddhdc,15767
+chatlas/_callbacks.py,sha256=3RpPaOQonTqScjXbaShgKJ1Rc-YxzWerxKRBjVssFnc,1838
+chatlas/_chat.py,sha256=uo8ucU0l59KkpOD93bbeJC6jqrM7DrzIKOl9g6PvhhY,56171
+chatlas/_content.py,sha256=KtQfJ3CATk_TGzGzihc_wWRuHdlLWp9Dr-OgxZQbOQE,15931
 chatlas/_content_image.py,sha256=EUK6wAint-JatLsiwvaPDu4D3W-NcIsDCkzABkXgfDg,8304
 chatlas/_content_pdf.py,sha256=cffeuJxzhUDukQ-Srkmpy62M8X12skYpU_FVq-Wvya4,2420
-chatlas/_databricks.py,sha256=h_RXsOzCp4k1h0byOkCVFOaNCnlapVP92tHs2yMbd6s,4692
+chatlas/_databricks.py,sha256=56dInk3UjQ5HqGiysn9TJ9hat745MhaFEn-IPfnR4vE,4696
 chatlas/_display.py,sha256=wyQzSc6z1VqrJfkTLkw1wQcti9s1Pr4qT8UxFJESn4U,4664
 chatlas/_github.py,sha256=xdGsvWvlbGMc1lgEM_oRL5p-wuxaZG-lu6a_4zxV-4Y,4235
 chatlas/_google.py,sha256=pwnomFcDEzPXQQfFifoH2FrbDvOgRIIyjcNoJ8Hvv-I,19397
 chatlas/_groq.py,sha256=0ou8iiAeI8EqjNKsLZhljQffSVOj8eCQEtW7-stZToY,4022
 chatlas/_interpolate.py,sha256=ykwLP3x-ya9Q33U4knSU75dtk6pzJAeythEEIW-43Pc,3631
 chatlas/_live_render.py,sha256=UMZltE35LxziDKPMEeDwQ9meZ95SeqwhJi7j-y9pcro,4004
-chatlas/_logging.py,sha256=7a20sAl1PkW1qBNrfd_ieUbQXV8Gf4Vuf0Wn62LNBmk,2290
+chatlas/_logging.py,sha256=weKvXZDIZ88X7X61ruXM_S0AAhQ5mgiW9dR-km8x7Mg,3324
 chatlas/_merge.py,sha256=SGj_BetgA7gaOqSBKOhYmW3CYeQKTEehFrXvx3y4OYE,3924
 chatlas/_ollama.py,sha256=_5Na11A7Hrs83CK8x542UHDvpLjQPyTJ9WM03eFDqKA,3627
 chatlas/_openai.py,sha256=qkU2DWOTsEVfjiAk4LDRszErVGLswiLwwim1zZnHn8o,23968
 chatlas/_perplexity.py,sha256=POp_Lc8RlSEsHIHhFlHOE8IVsOb2nf7mHQZvyQp49_U,4304
 chatlas/_provider.py,sha256=YmdBbz_u5aP_kBxl6s26OPiSnWG_vZ_fvf9L2qvBmyI,3809
-chatlas/_snowflake.py,sha256=xlDdaM-YCmz3Y8KU6jxdCICuS-H4XLpQBHjqnaiEqKk,11576
+chatlas/_snowflake.py,sha256=y9Lu5SFGsJ1QqQD0Xx7vsAwcBtw2_MWT1Vu7e0HQis0,24098
 chatlas/_tokens.py,sha256=3W3EPUp9eWXUiwuzJwEPBv43AUznbK46pm59Htti7z4,2392
 chatlas/_tokens_old.py,sha256=L9d9oafrXvEx2u4nIn_Jjn7adnQyLBnYBuPwJUE8Pl8,5005
-chatlas/_tools.py,sha256=-qt4U1AFkebQoX9kpsBy5QXK8a2PpHX6Amgm44gcQ68,4113
+chatlas/_tools.py,sha256=Qucyx_Pq-DX66r5xsZ7VRNxrIMS_se-FS7HH7jbB1A0,6085
 chatlas/_turn.py,sha256=7pve6YmD-L4c7Oxd6_ZAPkDudJ8AMpa6pP-pSroA1dM,5067
 chatlas/_typing_extensions.py,sha256=YdzmlyPSBpIEcsOkoz12e6jETT1XEMV2Q72haE4cfwY,1036
 chatlas/_utils.py,sha256=lli8ChbPUwEPebW8AoOoNoqiA95SVtoW2gb6ymj9gw4,4028
-chatlas/_version.py,sha256=UENolcbPfd6sim2GUd3djX88atGsPXEKCbPHv1Wucs4,511
+chatlas/_version.py,sha256=fSm5pLlwHxfTD7vBTVEqChJUua9ilUsdQYNN_V3u3iE,511
 chatlas/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chatlas/types/__init__.py,sha256=P_EDL4eqsigKwB-u2qRmKlYQS5Y65m7oWjGC3cYmxO4,719
 chatlas/types/anthropic/__init__.py,sha256=OwubA-DPHYpYo0XyRyAFwftOI0mOxtHzAyhUSLcDx54,417
 chatlas/types/anthropic/_client.py,sha256=G0LRhoFBcsSOMr5qhP-0rAScsVXaVlHCpggfVp54bnQ,690
 chatlas/types/anthropic/_client_bedrock.py,sha256=mNazQlu0pQt8JdzrYn3LKNgE4n732GjhQUJdQQK9QkY,785
-chatlas/types/anthropic/_submit.py,sha256=v_WJp8tK6HN86JiAEI_wCozCuLEduJpGEqVxXzvaYWw,3119
+chatlas/types/anthropic/_submit.py,sha256=FJPtswPf_NTV3kAXlFODin3bFOqYNdamopjIaVSSr24,3417
 chatlas/types/google/__init__.py,sha256=ZJhi8Kwvio2zp8T1TQqmvdHqkS-Khb6BGESPjREADgo,337
 chatlas/types/google/_client.py,sha256=t7aKbxYq_xOA1Z3RnWcjewifdQFSHi7vKEj6MyKMCJk,729
 chatlas/types/google/_submit.py,sha256=b-ZqMvI551Ia7pFlWdqUQJjov3neHmVwLFw-P2bgU8w,1883
 chatlas/types/openai/__init__.py,sha256=Q2RAr1bSH1nHsxICK05nAmKmxdhKmhbBkWD_XHiVSrI,411
 chatlas/types/openai/_client.py,sha256=YGm_EHtRSSHeeOZe-CV7oNvMJpEblEta3UTuU7lSRO8,754
 chatlas/types/openai/_client_azure.py,sha256=jx8D_p46CLDGzTP-k-TtGzj-f3junj6or-86m8DD_0w,858
-chatlas/types/openai/_submit.py,sha256=R0PUgXmhywLzRT_C3DYCsfbHCB1mD7cMY3zd8q7E-PU,6574
-chatlas/types/snowflake/__init__.py,sha256=NVKw_gLVnSlMNdE6BpikrQw8GV8LvIn5SR8eI8Afgbs,273
-chatlas/types/snowflake/_submit.py,sha256=Fgcb2Z4mXYwAR2b7Kn3SdEYFlO4gJiUvkDJ3lDoN0IY,799
-chatlas-0.7.1.dist-info/METADATA,sha256=BwSHMmxOYk0Pw9ykiBkwkeLAkKL3dg85QaalPd3byFU,15248
-chatlas-0.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-chatlas-0.7.1.dist-info/licenses/LICENSE,sha256=zyuGzPOC7CcbOaBHsQ3UEyKYRO56KDUkor0OA4LqqDg,1081
-chatlas-0.7.1.dist-info/RECORD,,
+chatlas/types/openai/_submit.py,sha256=FmDBq8Wg8R-GB3mFBCvAPHyniCyIkgrzwd_iOiAOLM8,6607
+chatlas-0.8.0.dist-info/METADATA,sha256=2qCNO5-g1k5DvVwJEkTwk8ve8TE16fWditQowVEhdH0,15255
+chatlas-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+chatlas-0.8.0.dist-info/licenses/LICENSE,sha256=zyuGzPOC7CcbOaBHsQ3UEyKYRO56KDUkor0OA4LqqDg,1081
+chatlas-0.8.0.dist-info/RECORD,,

chatlas/types/snowflake/__init__.py

@@ -1,8 +0,0 @@
-# ---------------------------------------------------------
-# Do not modify this file. It was generated by `scripts/generate_typed_dicts.py`.
-# ---------------------------------------------------------
-
-
-from ._submit import SubmitInputArgs
-
-__all__ = ("SubmitInputArgs",)

chatlas/types/snowflake/_submit.py

@@ -1,24 +0,0 @@
-# ---------------------------------------------------------
-# Do not modify this file. It was generated by `scripts/generate_typed_dicts.py`.
-# ---------------------------------------------------------
-
-
-from typing import Optional, TypedDict, Union
-
-import snowflake.cortex._complete
-import snowflake.snowpark.column
-import snowflake.snowpark.session
-
-
-class SubmitInputArgs(TypedDict, total=False):
-    model: Union[str, snowflake.snowpark.column.Column]
-    prompt: Union[
-        str,
-        list[snowflake.cortex._complete.ConversationMessage],
-        snowflake.snowpark.column.Column,
-    ]
-    options: Optional[snowflake.cortex._complete.CompleteOptions]
-    session: Optional[snowflake.snowpark.session.Session]
-    stream: bool
-    timeout: Optional[float]
-    deadline: Optional[float]