lm-deluge 0.0.41__tar.gz → 0.0.43__tar.gz

{lm_deluge-0.0.41/src/lm_deluge.egg-info → lm_deluge-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.41
+Version: 0.0.43
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10

{lm_deluge-0.0.41 → lm_deluge-0.0.43}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.41"
+version = "0.0.43"
 authors = [{ name = "Benjamin Anderson", email = "ben@trytaylor.ai" }]
 description = "Python utility for using LLM API models."
 readme = "README.md"

{lm_deluge-0.0.41 → lm_deluge-0.0.43}/src/lm_deluge/api_requests/bedrock.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import os
+import warnings
 
 from aiohttp import ClientResponse
 
@@ -135,27 +136,110 @@ async def _build_anthropic_bedrock_request(
     return request_json, base_headers, auth, url, region
 
 
+async def _build_openai_bedrock_request(
+    model: APIModel,
+    context: RequestContext,
+):
+    prompt = context.prompt
+    tools = context.tools
+    sampling_params = context.sampling_params
+
+    # Handle AWS auth
+    access_key = os.getenv("AWS_ACCESS_KEY_ID")
+    secret_key = os.getenv("AWS_SECRET_ACCESS_KEY")
+    session_token = os.getenv("AWS_SESSION_TOKEN")
+
+    if not access_key or not secret_key:
+        raise ValueError(
+            "AWS credentials not found. Please set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables."
+        )
+
+    # Determine region - GPT-OSS is available in us-west-2
+    region = "us-west-2"
+
+    # Construct the endpoint URL for OpenAI-compatible endpoint
+    service = "bedrock"
+    url = f"https://bedrock-runtime.{region}.amazonaws.com/openai/v1/chat/completions"
+
+    # Prepare headers
+    auth = AWS4Auth(
+        access_key,
+        secret_key,
+        region,
+        service,
+        session_token=session_token,
+    )
+
+    # Setup basic headers (AWS4Auth will add the Authorization header)
+    base_headers = {
+        "Content-Type": "application/json",
+    }
+
+    # Prepare request body in OpenAI format
+    request_json = {
+        "model": model.name,
+        "messages": prompt.to_openai(),
+        "temperature": sampling_params.temperature,
+        "top_p": sampling_params.top_p,
+        "max_completion_tokens": sampling_params.max_new_tokens,
+    }
+
+    # Note: GPT-OSS on Bedrock doesn't support response_format parameter
+    # Even though the model supports JSON, we can't use the response_format parameter
+    if sampling_params.json_mode and model.supports_json:
+        warnings.warn(
+            f"JSON mode requested for {model.name} but response_format parameter not supported on Bedrock"
+        )
+
+    if tools:
+        request_tools = []
+        for tool in tools:
+            if isinstance(tool, Tool):
+                request_tools.append(tool.dump_for("openai-completions"))
+            elif isinstance(tool, MCPServer):
+                as_tools = await tool.to_tools()
+                request_tools.extend(
+                    [t.dump_for("openai-completions") for t in as_tools]
+                )
+        request_json["tools"] = request_tools
+
+    return request_json, base_headers, auth, url, region
+
+
 class BedrockRequest(APIRequestBase):
     def __init__(self, context: RequestContext):
         super().__init__(context=context)
 
         self.model = APIModel.from_registry(self.context.model_name)
         self.region = None  # Will be set during build_request
+        self.is_openai_model = self.model.name.startswith("openai.")
 
     async def build_request(self):
-        self.url = f"{self.model.api_base}/messages"
-
-        # Lock images as bytes if caching is enabled
-        if self.context.cache is not None:
-            self.context.prompt.lock_images_as_bytes()
-
-        (
-            self.request_json,
-            base_headers,
-            self.auth,
-            self.url,
-            self.region,
-        ) = await _build_anthropic_bedrock_request(self.model, self.context)
+        if self.is_openai_model:
+            # Use OpenAI-compatible endpoint
+            (
+                self.request_json,
+                base_headers,
+                self.auth,
+                self.url,
+                self.region,
+            ) = await _build_openai_bedrock_request(self.model, self.context)
+        else:
+            # Use Anthropic-style endpoint
+            self.url = f"{self.model.api_base}/messages"
+
+            # Lock images as bytes if caching is enabled
+            if self.context.cache is not None:
+                self.context.prompt.lock_images_as_bytes()
+
+            (
+                self.request_json,
+                base_headers,
+                self.auth,
+                self.url,
+                self.region,
+            ) = await _build_anthropic_bedrock_request(self.model, self.context)
+
         self.request_header = self.merge_headers(
             base_headers, exclude_patterns=["anthropic", "openai", "gemini", "mistral"]
         )
@@ -232,34 +316,64 @@ class BedrockRequest(APIRequestBase):
         thinking = None
         content = None
         usage = None
+        finish_reason = None
         status_code = http_response.status
         mimetype = http_response.headers.get("Content-Type", None)
+        data = None
         assert self.context.status_tracker
 
         if status_code >= 200 and status_code < 300:
             try:
                 data = await http_response.json()
-                response_content = data["content"]
-
-                # Parse response into Message with parts
-                parts = []
-                for item in response_content:
-                    if item["type"] == "text":
-                        parts.append(Text(item["text"]))
-                    elif item["type"] == "thinking":
-                        thinking = item["thinking"]
-                        parts.append(Thinking(item["thinking"]))
-                    elif item["type"] == "tool_use":
-                        parts.append(
-                            ToolCall(
-                                id=item["id"],
-                                name=item["name"],
-                                arguments=item["input"],
+
+                if self.is_openai_model:
+                    # Handle OpenAI-style response
+                    parts = []
+                    message = data["choices"][0]["message"]
+                    finish_reason = data["choices"][0]["finish_reason"]
+
+                    # Add text content if present
+                    if message.get("content"):
+                        parts.append(Text(message["content"]))
+
+                    # Add tool calls if present
+                    if "tool_calls" in message:
+                        for tool_call in message["tool_calls"]:
+                            parts.append(
+                                ToolCall(
+                                    id=tool_call["id"],
+                                    name=tool_call["function"]["name"],
+                                    arguments=json.loads(
+                                        tool_call["function"]["arguments"]
+                                    ),
+                                )
+                            )
+
+                    content = Message("assistant", parts)
+                    usage = Usage.from_openai_usage(data["usage"])
+                else:
+                    # Handle Anthropic-style response
+                    response_content = data["content"]
+
+                    # Parse response into Message with parts
+                    parts = []
+                    for item in response_content:
+                        if item["type"] == "text":
+                            parts.append(Text(item["text"]))
+                        elif item["type"] == "thinking":
+                            thinking = item["thinking"]
+                            parts.append(Thinking(item["thinking"]))
+                        elif item["type"] == "tool_use":
+                            parts.append(
+                                ToolCall(
+                                    id=item["id"],
+                                    name=item["name"],
+                                    arguments=item["input"],
+                                )
                             )
-                        )
 
-                content = Message("assistant", parts)
-                usage = Usage.from_anthropic_usage(data["usage"])
+                    content = Message("assistant", parts)
+                    usage = Usage.from_anthropic_usage(data["usage"])
             except Exception as e:
                 is_error = True
                 error_message = (
@@ -275,6 +389,7 @@ class BedrockRequest(APIRequestBase):
             error_message = text
 
         # Handle special kinds of errors
+        retry_with_different_model = status_code in [529, 429, 400, 401, 403, 413]
         if is_error and error_message is not None:
             if (
                 "rate limit" in error_message.lower()
@@ -286,6 +401,7 @@ class BedrockRequest(APIRequestBase):
             if "context length" in error_message or "too long" in error_message:
                 error_message += " (Context length exceeded, set retries to 0.)"
                 self.context.attempts_left = 0
+            retry_with_different_model = True
 
         return APIResponse(
             id=self.context.task_id,
@@ -299,4 +415,7 @@ class BedrockRequest(APIRequestBase):
             region=self.region,
             sampling_params=self.context.sampling_params,
             usage=usage,
+            raw_response=data,
+            finish_reason=finish_reason,
+            retry_with_different_model=retry_with_different_model,
         )

{lm_deluge-0.0.41 → lm_deluge-0.0.43}/src/lm_deluge/api_requests/openai.py

@@ -113,6 +113,9 @@ class OpenAIRequest(APIRequestBase):
         finish_reason = None
         assert self.context.status_tracker
 
+        if status_code == 500:
+            print("Internal Server Error: ", (await http_response.text()))
+
         if status_code >= 200 and status_code < 300:
             try:
                 data = await http_response.json()
@@ -305,6 +308,9 @@ class OpenAIResponsesRequest(APIRequestBase):
         data = None
         assert self.context.status_tracker
 
+        if status_code == 500:
+            print("Internal Server Error: ", http_response.text())
+
         if status_code >= 200 and status_code < 300:
             try:
                 data = await http_response.json()
@@ -428,10 +434,12 @@ class OpenAIResponsesRequest(APIRequestBase):
                     error_message = f"Error parsing {self.model.name} responses API response: {str(e)}"
 
         elif mimetype and "json" in mimetype.lower():
+            print("is_error True, json response")
             is_error = True
             data = await http_response.json()
             error_message = json.dumps(data)
         else:
+            print("is_error True, non-json response")
             is_error = True
             text = await http_response.text()
             error_message = text

{lm_deluge-0.0.41 → lm_deluge-0.0.43}/src/lm_deluge/client.py

@@ -105,14 +105,8 @@ class _LLMClient(BaseModel):
 
     def _get_tracker(self) -> StatusTracker:
         if self._tracker is None:
-            self._tracker = StatusTracker(
-                max_requests_per_minute=self.max_requests_per_minute,
-                max_tokens_per_minute=self.max_tokens_per_minute,
-                max_concurrent_requests=self.max_concurrent_requests,
-                use_progress_bar=False,
-                progress_bar_disable=True,
-                progress_style=self.progress,
-            )
+            self.open()
+            assert self._tracker, "should have tracker now"
         return self._tracker
 
     @property
@@ -225,7 +219,6 @@ class _LLMClient(BaseModel):
     ):
         while True:
             async with self._capacity_lock:
-                tracker.update_capacity()
                 if tracker.check_capacity(num_tokens, retry=retry):
                     tracker.set_limiting_factor(None)
                     return
@@ -294,7 +287,7 @@ class _LLMClient(BaseModel):
 
             # Print error message for debugging
             error_msg = (
-                f"Error task {context.task_id}. Model: {response.model_internal}"
+                f"😔 Error task {context.task_id}. Model: {response.model_internal}"
             )
             if response.status_code:
                 error_msg += f" Code: {response.status_code},"
@@ -474,6 +467,7 @@ class _LLMClient(BaseModel):
         show_progress=True,
         tools: list[Tool | dict | MCPServer] | None = None,
         cache: CachePattern | None = None,
+        use_responses_api: bool = False,
     ):
         return asyncio.run(
             self.process_prompts_async(
@@ -482,6 +476,7 @@ class _LLMClient(BaseModel):
                 show_progress=show_progress,
                 tools=tools,
                 cache=cache,
+                use_responses_api=use_responses_api,
             )
         )
 

{lm_deluge-0.0.41 → lm_deluge-0.0.43}/src/lm_deluge/models/bedrock.py

@@ -96,4 +96,33 @@ BEDROCK_MODELS = {
         "tokens_per_minute": 400_000,
         "reasoning_model": True,
     },
+    # GPT-OSS on AWS Bedrock
+    "gpt-oss-120b-bedrock": {
+        "id": "gpt-oss-120b-bedrock",
+        "name": "openai.gpt-oss-120b-1:0",
+        "regions": ["us-west-2"],
+        "api_base": "",
+        "api_key_env_var": "",
+        "api_spec": "bedrock",
+        "input_cost": 0.0,
+        "output_cost": 0.0,
+        "supports_json": False,
+        "supports_logprobs": False,
+        "supports_responses": False,
+        "reasoning_model": False,
+    },
+    "gpt-oss-20b-bedrock": {
+        "id": "gpt-oss-20b-bedrock",
+        "name": "openai.gpt-oss-20b-1:0",
+        "regions": ["us-west-2"],
+        "api_base": "",
+        "api_key_env_var": "",
+        "api_spec": "bedrock",
+        "input_cost": 0.0,
+        "output_cost": 0.0,
+        "supports_json": False,
+        "supports_logprobs": False,
+        "supports_responses": False,
+        "reasoning_model": False,
+    },
 }

{lm_deluge-0.0.41 → lm_deluge-0.0.43/src/lm_deluge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.41
+Version: 0.0.43
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10