python-fastllm 0.0.42__tar.gz → 0.0.44__tar.gz

{python_fastllm-0.0.42/python_fastllm.egg-info → python_fastllm-0.0.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fastllm
-Version: 0.0.42
+Version: 0.0.44
 Author-email: Kerem Turgutlu <keremturgutlu@gmail.com>
 License: Apache-2.0
 Project-URL: Repository, https://github.com/AnswerDotAI/fastllm
@@ -12,6 +12,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: fastcore>=2.1.18
 Requires-Dist: aidialog>=0.0.10
 Requires-Dist: fastspec>=0.2.1
+Requires-Dist: fasttransport>=0.0.2
 Requires-Dist: pillow
 
 # fastllm
@@ -26,8 +27,7 @@ Clone and install locally into your `aai-ws` env
 ## Setup
 
 ``` python
-from fastllm.types import Completion
-from aidialog.msg_parts import Msg, Part, Text, Thinking, ToolUse, InputImage, mk_tool_res_msg
+from aidialog.msg_parts import Msg, Part, Text, Thinking, ToolUse, InputImage, mk_tool_res_msg, Completion
 from fastllm.acomplete import acomplete
 import asyncio, json
 
@@ -178,7 +178,9 @@ print("Tool calls:", r1.tool_calls)
 ```
 
     I'll check the current weather in Paris for you.
-    Tool calls: [ToolCall(id='toolu_01RMN1WM7vPBT3ovv5Ex6VzC', name='get_weather', arguments={'city': 'Paris'}, server=False, extra={'caller': {'type': 'direct'}})]
+    - ⏳ `get_weather(city="Paris")` ⏳
+
+    Tool calls: [ToolUse(raw={'caller': {'type': 'direct'}}, cache_control=None, id='toolu_01RMN1WM7vPBT3ovv5Ex6VzC', name='get_weather', arguments={'city': 'Paris'}, server=False, text=None)]
 
 ``` python
 # Provide the tool result
@@ -218,8 +220,9 @@ print("\nNo tools: ", end='')
 r = await stream([user("What's the weather?")], model='claude-sonnet-4-20250514', tools=tools, tool_choice='none', max_tokens=mtok)
 ```
 
+    - ⏳ `get_weather(city="<UNKNOWN>")` ⏳
 
-    Forced: [ToolCall(id='toolu_01U7tAXjXAtwjp6xNSMbsyPU', name='get_weather', arguments={'city': '<UNKNOWN>'}, server=False, extra={'caller': {'type': 'direct'}})]
+    Forced: [ToolUse(raw={'caller': {'type': 'direct'}}, cache_control=None, id='toolu_01U7tAXjXAtwjp6xNSMbsyPU', name='get_weather', arguments={'city': '<UNKNOWN>'}, server=False, text=None)]
 
     No tools: I'd be happy to help you get the weather information! However, I need to know which city you'd like me to check the weather for. Could you please tell me the city name?
 
@@ -281,7 +284,25 @@ r = await stream([user("What is the latest Python release?")], model='gpt-4o-min
 print(f"\nServer tools used: {[tc.name for tc in r.tool_calls if tc.server]}")
 ```
 
-    GPT + web search: As of June 12, 2026, the latest stable release of Python is version 3.14.5, which was released on May 10, 2026. ([test.python.org](https://test.python.org/downloads/latest?utm_source=openai))
+    GPT + web search: 
+
+    ```json {.tool}
+    {
+      "id": "ws_0f48f4b49d3a4937006a2c04cb944481a3882056257ae43956",
+      "name": "web_search",
+      "args": {
+        "type": "search",
+        "queries": [
+          "latest Python release October 2023"
+        ],
+        "query": "latest Python release October 2023"
+      },
+      "result": "Server tool call executed.",
+      "server": true
+    }
+    ```
+
+    As of June 12, 2026, the latest stable release of Python is version 3.14.5, which was released on May 10, 2026. ([test.python.org](https://test.python.org/downloads/latest?utm_source=openai))
 
     Python 3.14 introduced several significant features, including:
 

python_fastllm-0.0.42/PKG-INFO → python_fastllm-0.0.44/README.md

@@ -1,19 +1,3 @@
-Metadata-Version: 2.4
-Name: python-fastllm
-Version: 0.0.42
-Author-email: Kerem Turgutlu <keremturgutlu@gmail.com>
-License: Apache-2.0
-Project-URL: Repository, https://github.com/AnswerDotAI/fastllm
-Keywords: nbdev
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: fastcore>=2.1.18
-Requires-Dist: aidialog>=0.0.10
-Requires-Dist: fastspec>=0.2.1
-Requires-Dist: pillow
-
 # fastllm
 
 
@@ -26,8 +10,7 @@ Clone and install locally into your `aai-ws` env
 ## Setup
 
 ``` python
-from fastllm.types import Completion
-from aidialog.msg_parts import Msg, Part, Text, Thinking, ToolUse, InputImage, mk_tool_res_msg
+from aidialog.msg_parts import Msg, Part, Text, Thinking, ToolUse, InputImage, mk_tool_res_msg, Completion
 from fastllm.acomplete import acomplete
 import asyncio, json
 
@@ -178,7 +161,9 @@ print("Tool calls:", r1.tool_calls)
 ```
 
     I'll check the current weather in Paris for you.
-    Tool calls: [ToolCall(id='toolu_01RMN1WM7vPBT3ovv5Ex6VzC', name='get_weather', arguments={'city': 'Paris'}, server=False, extra={'caller': {'type': 'direct'}})]
+    - ⏳ `get_weather(city="Paris")` ⏳
+
+    Tool calls: [ToolUse(raw={'caller': {'type': 'direct'}}, cache_control=None, id='toolu_01RMN1WM7vPBT3ovv5Ex6VzC', name='get_weather', arguments={'city': 'Paris'}, server=False, text=None)]
 
 ``` python
 # Provide the tool result
@@ -218,8 +203,9 @@ print("\nNo tools: ", end='')
 r = await stream([user("What's the weather?")], model='claude-sonnet-4-20250514', tools=tools, tool_choice='none', max_tokens=mtok)
 ```
 
+    - ⏳ `get_weather(city="<UNKNOWN>")` ⏳
 
-    Forced: [ToolCall(id='toolu_01U7tAXjXAtwjp6xNSMbsyPU', name='get_weather', arguments={'city': '<UNKNOWN>'}, server=False, extra={'caller': {'type': 'direct'}})]
+    Forced: [ToolUse(raw={'caller': {'type': 'direct'}}, cache_control=None, id='toolu_01U7tAXjXAtwjp6xNSMbsyPU', name='get_weather', arguments={'city': '<UNKNOWN>'}, server=False, text=None)]
 
     No tools: I'd be happy to help you get the weather information! However, I need to know which city you'd like me to check the weather for. Could you please tell me the city name?
 
@@ -281,7 +267,25 @@ r = await stream([user("What is the latest Python release?")], model='gpt-4o-min
 print(f"\nServer tools used: {[tc.name for tc in r.tool_calls if tc.server]}")
 ```
 
-    GPT + web search: As of June 12, 2026, the latest stable release of Python is version 3.14.5, which was released on May 10, 2026. ([test.python.org](https://test.python.org/downloads/latest?utm_source=openai))
+    GPT + web search: 
+
+    ```json {.tool}
+    {
+      "id": "ws_0f48f4b49d3a4937006a2c04cb944481a3882056257ae43956",
+      "name": "web_search",
+      "args": {
+        "type": "search",
+        "queries": [
+          "latest Python release October 2023"
+        ],
+        "query": "latest Python release October 2023"
+      },
+      "result": "Server tool call executed.",
+      "server": true
+    }
+    ```
+
+    As of June 12, 2026, the latest stable release of Python is version 3.14.5, which was released on May 10, 2026. ([test.python.org](https://test.python.org/downloads/latest?utm_source=openai))
 
     Python 3.14 introduced several significant features, including:
 

python_fastllm-0.0.44/fastllm/__init__.py

@@ -0,0 +1,5 @@
+"""Modules:
+
+- `fastllm.responses`: Provider-independent Responses resources and streaming over FastLLM"""
+
+__version__ = "0.0.44"

{python_fastllm-0.0.42 → python_fastllm-0.0.44}/fastllm/_modidx.py

@@ -141,6 +141,7 @@ d = { 'settings': { 'branch': 'main',
                                 'fastllm.gemini.denorm_user': ('gemini.html#denorm_user', 'fastllm/gemini.py'),
                                 'fastllm.gemini.denorm_video': ('gemini.html#denorm_video', 'fastllm/gemini.py'),
                                 'fastllm.gemini.denorm_web_search': ('gemini.html#denorm_web_search', 'fastllm/gemini.py'),
+                                'fastllm.gemini.endpoint': ('gemini.html#endpoint', 'fastllm/gemini.py'),
                                 'fastllm.gemini.get_hdrs': ('gemini.html#get_hdrs', 'fastllm/gemini.py'),
                                 'fastllm.gemini.mk_payload': ('gemini.html#mk_payload', 'fastllm/gemini.py'),
                                 'fastllm.gemini.norm_finish': ('gemini.html#norm_finish', 'fastllm/gemini.py'),
@@ -167,13 +168,18 @@ d = { 'settings': { 'branch': 'main',
                                      'fastllm.openai_chat.denorm_tool_use': ('oai_chat.html#denorm_tool_use', 'fastllm/openai_chat.py'),
                                      'fastllm.openai_chat.denorm_user': ('oai_chat.html#denorm_user', 'fastllm/openai_chat.py'),
                                      'fastllm.openai_chat.denorm_web_search': ('oai_chat.html#denorm_web_search', 'fastllm/openai_chat.py'),
+                                     'fastllm.openai_chat.fix_payload': ('oai_chat.html#fix_payload', 'fastllm/openai_chat.py'),
                                      'fastllm.openai_chat.get_hdrs': ('oai_chat.html#get_hdrs', 'fastllm/openai_chat.py'),
                                      'fastllm.openai_chat.mk_payload': ('oai_chat.html#mk_payload', 'fastllm/openai_chat.py'),
                                      'fastllm.openai_chat.norm_finish': ('oai_chat.html#norm_finish', 'fastllm/openai_chat.py'),
                                      'fastllm.openai_chat.norm_parts': ('oai_chat.html#norm_parts', 'fastllm/openai_chat.py'),
                                      'fastllm.openai_chat.norm_sse_event': ('oai_chat.html#norm_sse_event', 'fastllm/openai_chat.py'),
                                      'fastllm.openai_chat.norm_tool_calls': ('oai_chat.html#norm_tool_calls', 'fastllm/openai_chat.py')},
-            'fastllm.openai_responses': { 'fastllm.openai_responses._sanid': ('oai_responses.html#_sanid', 'fastllm/openai_responses.py'),
+            'fastllm.openai_responses': { 'fastllm.openai_responses.Completion.response_id': ( 'oai_responses.html#completion.response_id',
+                                                                                               'fastllm/openai_responses.py'),
+                                          'fastllm.openai_responses.Completion.response_id_reusable': ( 'oai_responses.html#completion.response_id_reusable',
+                                                                                                        'fastllm/openai_responses.py'),
+                                          'fastllm.openai_responses._sanid': ('oai_responses.html#_sanid', 'fastllm/openai_responses.py'),
                                           'fastllm.openai_responses.acollect_stream': ( 'oai_responses.html#acollect_stream',
                                                                                         'fastllm/openai_responses.py'),
                                           'fastllm.openai_responses.cost': ('oai_responses.html#cost', 'fastllm/openai_responses.py'),
@@ -207,6 +213,8 @@ d = { 'settings': { 'branch': 'main',
                                                                                      'fastllm/openai_responses.py'),
                                           'fastllm.openai_responses.denorm_web_search': ( 'oai_responses.html#denorm_web_search',
                                                                                           'fastllm/openai_responses.py'),
+                                          'fastllm.openai_responses.fix_payload': ( 'oai_responses.html#fix_payload',
+                                                                                    'fastllm/openai_responses.py'),
                                           'fastllm.openai_responses.get_hdrs': ( 'oai_responses.html#get_hdrs',
                                                                                  'fastllm/openai_responses.py'),
                                           'fastllm.openai_responses.mk_payload': ( 'oai_responses.html#mk_payload',
@@ -223,6 +231,50 @@ d = { 'settings': { 'branch': 'main',
                                                                                         'fastllm/openai_responses.py'),
                                           'fastllm.openai_responses.norm_usage': ( 'oai_responses.html#norm_usage',
                                                                                    'fastllm/openai_responses.py')},
+            'fastllm.responses': { 'fastllm.responses.AsyncResponses': ('responses.html#asyncresponses', 'fastllm/responses.py'),
+                                   'fastllm.responses.AsyncResponses.call': ('responses.html#asyncresponses.call', 'fastllm/responses.py'),
+                                   'fastllm.responses.AsyncResponses.events': ( 'responses.html#asyncresponses.events',
+                                                                                'fastllm/responses.py'),
+                                   'fastllm.responses.AsyncResponses.prepare': ( 'responses.html#asyncresponses.prepare',
+                                                                                 'fastllm/responses.py'),
+                                   'fastllm.responses.AsyncResponses.state': ( 'responses.html#asyncresponses.state',
+                                                                               'fastllm/responses.py'),
+                                   'fastllm.responses.ResponseState': ('responses.html#responsestate', 'fastllm/responses.py'),
+                                   'fastllm.responses.ResponseState.__init__': ( 'responses.html#responsestate.__init__',
+                                                                                 'fastllm/responses.py'),
+                                   'fastllm.responses.ResponseTurn': ('responses.html#responseturn', 'fastllm/responses.py'),
+                                   'fastllm.responses.ResponseTurn.__init__': ( 'responses.html#responseturn.__init__',
+                                                                                'fastllm/responses.py'),
+                                   'fastllm.responses.ResponseTurn.provider_previous_id': ( 'responses.html#responseturn.provider_previous_id',
+                                                                                            'fastllm/responses.py'),
+                                   'fastllm.responses.ResponsesError': ('responses.html#responseserror', 'fastllm/responses.py'),
+                                   'fastllm.responses.ResponsesError.__init__': ( 'responses.html#responseserror.__init__',
+                                                                                  'fastllm/responses.py'),
+                                   'fastllm.responses._ResponseStream': ('responses.html#_responsestream', 'fastllm/responses.py'),
+                                   'fastllm.responses._ResponseStream.__init__': ( 'responses.html#_responsestream.__init__',
+                                                                                   'fastllm/responses.py'),
+                                   'fastllm.responses._ResponseStream.done_events': ( 'responses.html#_responsestream.done_events',
+                                                                                      'fastllm/responses.py'),
+                                   'fastllm.responses._ResponseStream.event': ( 'responses.html#_responsestream.event',
+                                                                                'fastllm/responses.py'),
+                                   'fastllm.responses._ResponseStream.part_events': ( 'responses.html#_responsestream.part_events',
+                                                                                      'fastllm/responses.py'),
+                                   'fastllm.responses._ResponseStream.text_events': ( 'responses.html#_responsestream.text_events',
+                                                                                      'fastllm/responses.py'),
+                                   'fastllm.responses._ResponseStream.tool_events': ( 'responses.html#_responsestream.tool_events',
+                                                                                      'fastllm/responses.py'),
+                                   'fastllm.responses._arguments': ('responses.html#_arguments', 'fastllm/responses.py'),
+                                   'fastllm.responses._msg_parts': ('responses.html#_msg_parts', 'fastllm/responses.py'),
+                                   'fastllm.responses._new_id': ('responses.html#_new_id', 'fastllm/responses.py'),
+                                   'fastllm.responses._response_base': ('responses.html#_response_base', 'fastllm/responses.py'),
+                                   'fastllm.responses._text_content': ('responses.html#_text_content', 'fastllm/responses.py'),
+                                   'fastllm.responses.normalize_call_ids': ('responses.html#normalize_call_ids', 'fastllm/responses.py'),
+                                   'fastllm.responses.pending_response': ('responses.html#pending_response', 'fastllm/responses.py'),
+                                   'fastllm.responses.response_event': ('responses.html#response_event', 'fastllm/responses.py'),
+                                   'fastllm.responses.response_input': ('responses.html#response_input', 'fastllm/responses.py'),
+                                   'fastllm.responses.response_object': ('responses.html#response_object', 'fastllm/responses.py'),
+                                   'fastllm.responses.response_output': ('responses.html#response_output', 'fastllm/responses.py'),
+                                   'fastllm.responses.response_usage': ('responses.html#response_usage', 'fastllm/responses.py')},
             'fastllm.streaming': { 'fastllm.streaming.Delta': ('streaming.html#delta', 'fastllm/streaming.py'),
                                    'fastllm.streaming.Delta.__eq__': ('streaming.html#delta.__eq__', 'fastllm/streaming.py'),
                                    'fastllm.streaming.Delta.__hash__': ('streaming.html#delta.__hash__', 'fastllm/streaming.py'),
@@ -279,6 +331,7 @@ d = { 'settings': { 'branch': 'main',
                                'fastllm.types.model_prices_meta': ('types.html#model_prices_meta', 'fastllm/types.py'),
                                'fastllm.types.payload_kwargs': ('types.html#payload_kwargs', 'fastllm/types.py'),
                                'fastllm.types.price_tier': ('types.html#price_tier', 'fastllm/types.py'),
+                               'fastllm.types.provider_req': ('types.html#provider_req', 'fastllm/types.py'),
                                'fastllm.types.register_model_info': ('types.html#register_model_info', 'fastllm/types.py'),
                                'fastllm.types.resize_b64': ('types.html#resize_b64', 'fastllm/types.py'),
                                'fastllm.types.tier_rate': ('types.html#tier_rate', 'fastllm/types.py'),

{python_fastllm-0.0.42 → python_fastllm-0.0.44}/fastllm/acomplete.py

@@ -3,16 +3,13 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/06_acomplete.ipynb.
 
 # %% auto #0
-__all__ = ['specs_path', 'ant_spec', 'oai_spec', 'gem_spec', 'vendor_mapping', 'api2spec', 'defaults', 'split_vendor',
-           'mk_client', 'ContextWindowExceededError', 'acomplete']
+__all__ = ['vendor_mapping', 'defaults', 'split_vendor', 'mk_client', 'ContextWindowExceededError', 'acomplete']
 
 # %% ../nbs/06_acomplete.ipynb #f2f57253
 import asyncio,json,httpx2
-from importlib.resources import files
 from fastcore.utils import *
 from fastcore.meta import *
-from fastspec.spec import *
-from fastspec.oapi import *
+from fasttransport.core import AsyncHttpCli
 from fastspec.errors import APIError
 
 from .types import *
@@ -24,12 +21,6 @@ from .openai_chat import *
 from .anthropic import *
 from .gemini import *
 
-# %% ../nbs/06_acomplete.ipynb #6d11ac28
-specs_path = files('fastllm') / 'specs'
-ant_spec  = SpecParser.from_openapi(dict2obj(json.loads((specs_path/'anthropic.json').read_text())))
-oai_spec  = SpecParser.from_openapi(dict2obj(json.loads((specs_path/'openai.with-code-samples.json').read_text())))
-gem_spec  = SpecParser.from_discovery(dict2obj(json.loads((specs_path/'gemini.json').read_text())))
-
 # %% ../nbs/06_acomplete.ipynb #32ee2546
 _codex_path = os.getenv('CODEX_AUTH_PATH', '~/.codex/auth.json')
 _codex_json = _codex_path, ('tokens','access_token')
@@ -47,11 +38,8 @@ vendor_mapping = {
     "fireworks_ai": ('openai_chat', "https://api.fireworks.ai/inference/v1", "FIREWORKS_API_KEY"),
     "qwen":         ('openai_chat', "https://dashscope.aliyuncs.com/compatible-mode/v1", "QWEN_API_KEY"),
     "minimax":      ('anthropic', "https://api.minimax.io/anthropic", "MINIMAX_API_KEY"),
-    "meta_ai":      ('openai', "https://api.meta.ai/v1", "META_API_KEY")
-}
-
-# %% ../nbs/06_acomplete.ipynb #77d27ea7
-api2spec = {'openai':oai_spec, 'openai_chat':oai_spec, 'anthropic':ant_spec, 'gemini':gem_spec}
+    "meta_ai":      ('openai', "https://api.meta.ai/v1", "META_API_KEY"),
+    "zai":          ('openai_chat', "https://api.z.ai/api/paas/v4", "ZAI_API_KEY")}
 
 # %% ../nbs/06_acomplete.ipynb #e3ed40fb
 def split_vendor(model):
@@ -96,13 +84,11 @@ def mk_client(model=None, vendor_name=None, api_name=None, api_key=None, base_ur
             api_key = get_api_key(api_key, env_api_nm)
         except KeyError: raise ValueError(f"Unknown vendor '{vendor_name}', {err_msg}")
     elif base_url and api_key: vendor_name, api_name = ifnone(vendor_name, 'custom'), ifnone(api_name, 'openai_chat')
-    elif (api_name:=infer_api_name(model)):  base_url, vendor_name = None, api_name
+    elif (api_name:=infer_api_name(model)):  base_url, vendor_name = vendor_mapping[api_name][1], api_name
     else: raise ValueError(f"Model {model} can't be auto resolved, {err_msg}")
     api = api_registry[api_name]
-    spec, hdrs = api2spec[api_name], api.get_hdrs(api_key)
-    cli = OpenAPIClient(spec, headers=merge(hdrs, ifnone(xtra_hdrs, {})), timeout=timeout)
-    if base_url is not None:
-        for op in cli.ops: op.base_url = base_url  # pyright: ignore[reportAttributeAccessIssue]
+    hdrs = merge(api.get_hdrs(api_key), ifnone(xtra_hdrs, {}))
+    cli = AsyncHttpCli(base_url, base_headers=hdrs, timeout=timeout)
     return cli, api_name, vendor_name
 
 # %% ../nbs/06_acomplete.ipynb #df851a5c
@@ -113,8 +99,8 @@ def _is_ctx_exceeded(code, msg):
     if any(x in m for x in ("string_above_max_length", "invalid 'user'")): return False
     if str(code or "").lower() == "context_length_exceeded": return True
     return any(s in m for s in ("exceed context limit", "maximum context length", "maximum context limit",
-    "longer than the model's context length", "input tokens exceed the configured limit",
-    "exceeds the maximum number of tokens allowed", "prompt is too long", "exceeds the context window"))
+        "longer than the model's context length", "input tokens exceed the configured limit",
+        "exceeds the maximum number of tokens allowed", "prompt is too long", "exceeds the context window"))
 
 def _classify_error(exc):
     "Upgrade generic `APIError` to a specific subclass if applicable."
@@ -134,14 +120,13 @@ async def _classify_error_stream(gen):
 # %% ../nbs/06_acomplete.ipynb #f626a4e1
 defaults = SimpleNamespace(debug_mode=False)
 
-def _debug_print(model, api_name, vendor_name, payload, func):
+def _debug_print(model, api_name, vendor_name, payload, url):
     "Pretty-print acomplete inputs when defaults.debug_mode is set"
     from pprint import pformat
     p = dict(payload)
-    if defaults.debug_mode == 'brief' and 'tools' in p:
-        p['tools'] = '; '.join(o.get('name', o.get('type', o)) for o in p['tools'])
+    if defaults.debug_mode == 'brief' and 'tools' in p: p['tools'] = '; '.join(o.get('name', o.get('type', o)) for o in p['tools'])
     print('━'*60)
-    print(f"\033[1;36mfastllm debug\033[0m  model={model} vendor={vendor_name} api={api_name} base_url={func.base_url} path={func.path}")
+    print(f"\033[1;36mfastllm debug\033[0m  model={model} vendor={vendor_name} api={api_name} url={url}")
     print('─'*60)
     print(f"\033[1;33mpayload:\033[0m\n{pformat(p, width=120, sort_dicts=False)}")
     print('━'*60)
@@ -169,39 +154,36 @@ async def _retry_stream(mk_gen, retries=2, retry_delay=0.5):
 
 # %% ../nbs/06_acomplete.ipynb #2379ec94
 @delegates(payload_kwargs)
-async def acomplete(msgs, model, api_name=None, vendor_name=None, api_key=None,
-                    base_url=None, xtra_body=None, xtra_hdrs=None, stream=False,
-                    stop_callables=None, retries=2, retry_delay=0.5, **kwargs):
+async def acomplete(msgs, model, api_name=None, vendor_name=None, api_key=None, base_url=None, endpoint=None, xtra_body=None, xtra_hdrs=None,
+    stream=False, previous_response_id=None, stop_callables=None, retries=2, retry_delay=0.5, **kwargs):
     "Unified completion across different APIs."
     if not vendor_name and not api_name and not (base_url and api_key):
         v, m = split_vendor(model)
         if v in vendor_mapping: vendor_name, model = v, m
         elif v: api_name, model = v, m  # a registered transport api (e.g. claude_code): not an HTTP vendor
-    if api_name == 'claude_code':
-        if not stream: raise NotImplementedError("claude_code backend supports stream=True only for now")
-        api = api_registry[api_name]
-        payload = api.mk_payload(msgs, model, stream=stream, **kwargs)
-        async def _mk_gen():
-            async for o in api.acollect_stream(payload, model=model, vendor_name='claude_code', stop_callables=stop_callables): yield o
-        return _retry_stream(_mk_gen, retries, retry_delay)
-    cli, api_name, vendor_name = mk_client(model=model, vendor_name=vendor_name, api_name=api_name, api_key=api_key, base_url=base_url, xtra_hdrs=xtra_hdrs)
+    own = api_name in api_registry and not hasattr(api_registry[api_name], 'endpoint') if api_name else False
+    if own: vendor_name = ifnone(vendor_name, api_name)  # an own-transport api: no HTTP client to build
+    else: cli, api_name, vendor_name = mk_client(model=model, vendor_name=vendor_name, api_name=api_name, api_key=api_key, base_url=base_url, xtra_hdrs=xtra_hdrs)
     api = api_registry[api_name]
+    if previous_response_id is not None:
+        if not getattr(api, 'supports_previous_response_id', False):
+            raise ValueError('previous_response_id is not supported by this transport')
+        kwargs['previous_response_id'] = previous_response_id
     payload = api.mk_payload(msgs, model, stream=stream, **kwargs)
-    payload = merge(payload, ifnone(xtra_body, {}))
-    if vendor_name == 'codex':
-        for k in 'temperature max_tokens max_output_tokens max_completion_tokens metadata'.split(): payload.pop(k, None)
-        payload['store'] = False
-    if nested_idx(payload, 'messages', -1, 'role') == 'assistant':
-        if vendor_name == 'deepseek' and 'v4' in model:   payload['messages'][-1]['prefix'] = True
-        if vendor_name == 'moonshot' and 'kimi' in model: payload['messages'][-1]['partial'] = True
-    func = attrgetter(api.op_path[stream])(cli)
-    if defaults.debug_mode: _debug_print(model, api_name, vendor_name, payload, func)
-    async def _call(): return await func(**payload)
-    if not stream:
-        resp = await _retry_call(_call, retries, retry_delay)
-        return mk_completion(resp, model=model, api_name=api_name, vendor_name=vendor_name)
-
+    xtra_body = ifnone(xtra_body, {})
+    if fix := getattr(api, 'fix_payload', None): fix(payload, model, vendor_name)
+    if not own:
+        ep = endpoint or api.endpoint
+        path,params = ep(model, stream) if callable(ep) else (ep, None)
+    if defaults.debug_mode: _debug_print(model, api_name, vendor_name, payload | xtra_body, None if own else cli._url(path))
+    async def _call(): return await provider_req(cli, path, payload | xtra_body, params=params, stream=stream)
     async def _mk_gen():
-        resp = await _call()
+        resp = payload if own else await _call()  # an own-transport api's `acollect_stream` makes the request itself, from the payload
         async for o in api.acollect_stream(resp, model=model, vendor_name=vendor_name, stop_callables=stop_callables): yield o
-    return _retry_stream(_mk_gen, retries, retry_delay)
+    if stream or own:
+        result = _retry_stream(_mk_gen, retries, retry_delay)
+        if stream: return result
+        async for completion in result: pass  # own-transport apis are streaming-only: drain for the completion
+        return completion
+    resp = await _retry_call(_call, retries, retry_delay)
+    return mk_completion(resp, model=model, api_name=api_name, vendor_name=vendor_name)

{python_fastllm-0.0.42 → python_fastllm-0.0.44}/fastllm/anthropic.py

@@ -343,4 +343,4 @@ def cost(usage, m):
 # %% ../nbs/04_anthropic.ipynb #f7c0b989
 api_registry.register('anthropic', norm_tool_calls=norm_tool_calls, norm_parts=norm_parts, norm_finish=norm_finish, norm_usage=norm_usage,
     finalize_usage=finalize_usage, acollect_stream=acollect_stream, mk_payload=mk_payload, cost=cost, get_hdrs=get_hdrs,
-    op_path=('messages.messages_post','messages.messages_post'))
+    endpoint='/v1/messages')

{python_fastllm-0.0.42 → python_fastllm-0.0.44}/fastllm/chat.py

@@ -71,7 +71,7 @@ def _mk_tool_result(res):
 # %% ../nbs/07_chat.ipynb #a0fcc96e
 def _call_func(tc:ToolUse, tool_schemas, ns, callf):
     "Call tool function synchronously and return formatted result"
-    fn, valid = tc.name, {nested_idx(o,'function','name') for o in tool_schemas or []}
+    fn, valid = tc.name, {fs[0] for o in tool_schemas or [] if (fs:=fn_schema(o))}
     if fn not in valid: return f"Tool not defined in tool_schemas: {fn}"
     else: return callf(fn, tc.arguments, ns=ns, raise_on_err=False)
 
@@ -92,14 +92,14 @@ async def structured(
 ):
     "Return the value of the tool call (generally used for structured outputs)"
     t = lite_mk_func(tool)
-    r = await acomplete(msgs, m, system=sp, tools=[t], tool_choice=nested_idx(t, 'function', 'name'), **kwargs)
+    r = await acomplete(msgs, m, system=sp, tools=[t], tool_choice=fn_schema(t)[0], **kwargs)
     return tool(**r.tool_calls[0].arguments)
 
 # %% ../nbs/07_chat.ipynb #1fe8a9bc
 def _has_search(info): return bool(info.get('search_context_cost_per_query') or info.get('supports_web_search'))
 
 # %% ../nbs/07_chat.ipynb #2d78087b
-effort = AttrDict({o[0]:o for o in ('low','medium','high')})
+effort = AttrDict({o[0]:o for o in ('none','low','medium','high')})
 effort['x'] = 'max'
 
 # %% ../nbs/07_chat.ipynb #dc17f844
@@ -125,10 +125,9 @@ class UsageStats:
     @classmethod
     def from_response(cls, r):
         u = r.usage
-        return cls(
-            model=r.model or '', prompt_tokens=u.prompt_tokens or 0, completion_tokens=u.completion_tokens or 0, total_tokens=u.total_tokens or 0,
-            cached_tokens=u.cached_tokens or 0, cache_creation_tokens=u.cache_creation_tokens or 0, reasoning_tokens=u.reasoning_tokens or 0,
-            web_search_requests=search_count(r), cost=r.cost)
+        return cls(model=r.model or '', prompt_tokens=u.prompt_tokens or 0, completion_tokens=u.completion_tokens or 0,
+            total_tokens=u.total_tokens or 0, cached_tokens=u.cached_tokens or 0, cache_creation_tokens=u.cache_creation_tokens or 0,
+            reasoning_tokens=u.reasoning_tokens or 0, web_search_requests=search_count(r), cost=r.cost)
 
     def __add__(self, other):
         if other is None: return self
@@ -170,7 +169,9 @@ class AsyncChat:
         vendor_name=None,         # Vendor name, one of vendor_mapping which resolves api_base/api_key automatically
         api_key=None,             # API key when model can't be resolved or vendor_name is not known or codex
         base_url=None,            # API base url when model can't be resolved or vendor_name is not known
+        endpoint=None,            # Override the transport's request path, for a server mounting Responses at a custom location
         extra_headers=None,       # Extra HTTP headers for custom providers
+        use_previous_response_id=False, # Continue tool rounds with Responses IDs instead of replaying history
         markup=0,                 # Cost markup multiplier (e.g. 0.5 for 50%)
         showthink=False,          # Stamp streamed thinking parts to display their text rather than 🧠 glyphs
         cbs:list=None,            # Chat callbacks
@@ -187,6 +188,7 @@ class AsyncChat:
         elif ns is None: ns = globals()
         self.tool_schemas = [lite_mk_func(t) for t in tools] if tools else None
         self.use = UsageStats()
+        self.response_id,self._response_hist_idx = None,0
         self._turn_start = 0    # index into `hist` where the current turn began, for `full`
         self.last_req_use = None  # usage of the latest request only; `use` accumulates across a turn's tool-call steps
         store_attr(but='cbs')
@@ -223,7 +225,10 @@ class AsyncChat:
 def _usrtools(tcs): return L(tcs).filter(lambda o: not o.server) if tcs else None
 
 # %% ../nbs/07_chat.ipynb #19b87f53
+_effort_names = dict(none='n', low='l', medium='m', high='h', xhigh='x', max='x')
+
 def _think_kw(model, think, vendor_name):
+    think = _effort_names.get(think, think)
     if not think: return {}
     if 'opus-4-7' in model:
         e = 'xhigh' if think=='h' else effort.get(think)
@@ -250,6 +255,7 @@ def _prep_call(self:AsyncChat, search, max_tokens, kwargs, stream=False, think=N
     if self.vendor_name:   kwargs['vendor_name'] = self.vendor_name
     if self.api_key:       kwargs['api_key'] = self.api_key
     if self.base_url:      kwargs['base_url'] = self.base_url
+    if self.endpoint:      kwargs['endpoint'] = self.endpoint
     if self.extra_headers: kwargs['xtra_headers'] = self.extra_headers
     kwargs.update(_think_kw(self.model, think, self.vendor_name))
     return max_tokens
@@ -276,19 +282,23 @@ async def astream_with_complete(self, agen, postproc=noop):
 # %% ../nbs/07_chat.ipynb #a049cf52
 @patch
 @delegates(acomplete)
-async def _call(self:AsyncChat, msg=None, temp=None, think=None, search=None, stream=False, max_steps=2, step=1,
-    final_prompt=None, tool_choice=None, max_tokens=None, n_workers=8, pause=0.001, tc_timeout=7200, **kwargs):
-    if step>max_steps+1: return
-    max_tokens = self._prep_call(search, max_tokens, kwargs, stream=stream, think=think)
-    self.turn_sysp, self.turn_msgs = self._prep_msg(msg)
+async def _call(self:AsyncChat, msg=None, step=1, search=None, tool_choice=None, initial_body=None, **kwargs):
+    "One model turn plus its tool round, recursing for the next; turn-constant options come from `turn_opts`"
+    t = AttrDict(self.turn_opts)
+    if step>t.max_steps+1: return
+    max_tokens = self._prep_call(search, t.max_tokens, kwargs, stream=t.stream, think=t.think)
+    self.turn_sysp, turn_msgs = self._prep_msg(msg)
+    self.turn_msgs = turn_msgs[self._response_hist_idx:] if self.response_id else turn_msgs
     async for o in self._call_cbs('after_msgs'): yield o
 
-    self.turn_kwargs, self.stream = kwargs, stream
+    self.turn_kwargs, self.stream = kwargs, t.stream
+    kw = merge(kwargs, dict(xtra_body=merge(kwargs.get('xtra_body'), initial_body))) if initial_body else kwargs
     async for o in self._call_cbs('before_acomplete'): yield o
-    res = await acomplete(self.turn_msgs, self.model, system=self.turn_sysp, stream=stream, tools=self.tool_schemas,
-        tool_choice=tool_choice, max_tokens=int(max_tokens), temperature=None if think else ifnone(temp,self.temp),
-        cache_idxs=self.cache_idxs if self.cache else [], ttl=self.ttl, **self.turn_kwargs)
-    if stream:
+    res = await acomplete(self.turn_msgs, self.model, system=self.turn_sysp, stream=t.stream, tools=self.tool_schemas,
+        tool_choice=tool_choice, max_tokens=int(max_tokens), temperature=None if t.think else ifnone(t.temp,self.temp),
+        previous_response_id=self.response_id if self.use_previous_response_id else None,
+        cache_idxs=self.cache_idxs if self.cache else [], ttl=self.ttl, **kw)
+    if t.stream:
         res = astream_with_complete(res, postproc=postproc)
         async for chunk in res:
             if isinstance(chunk, Thinking) and self.showthink: chunk.showthink = True
@@ -296,6 +306,10 @@ async def _call(self:AsyncChat, msg=None, temp=None, think=None, search=None, st
         res = res.value
     self.turn_res, self.turn_msg = res, contents(res)
     self.hist.append(self.turn_msg)
+    if self.use_previous_response_id:
+        if res.response_id: self.response_id,self._response_hist_idx = res.response_id,len(self.hist)
+        elif res.tool_calls: raise ValueError('tool-call response requires a continuation-capable transport')
+        else: self.response_id,self._response_hist_idx = None,0
     async for o in self._call_cbs('after_acomplete'): yield o
     self._track(self.turn_res)
     yield res
@@ -303,46 +317,51 @@ async def _call(self:AsyncChat, msg=None, temp=None, think=None, search=None, st
     self.toolloop, self.prompt, tmsg = False, None, None
     async for o in self._call_cbs('before_tool_calls'): yield o
     if tcs := _usrtools(res.tool_calls):
-        tres = await parallel_async(_alite_call_func, tcs, timeout=tc_timeout, n_workers=n_workers, pause=pause, **self.tcdict)
+        tres = await parallel_async(_alite_call_func, tcs, timeout=t.tc_timeout, n_workers=t.n_workers, pause=t.pause, **self.tcdict)
         tmsg = mk_tool_res_msg(tcs, tres)
         for r in tmsg.content: yield r
         self.hist.append(tmsg)
         yield Refresh()
-        if step>=max_steps-1 or _has_stop(tmsg.content): self.prompt,tool_choice,search = mk_msg(final_prompt),'none',False
+        if step>=t.max_steps-1 or _has_stop(tmsg.content): self.prompt,tool_choice,search = mk_msg(t.final_prompt),'none',False
         self.toolloop = True
 
     async for o in self._call_cbs('after_tool_calls'): yield o
-    if self.toolloop and step <= max_steps:
+    if self.toolloop and step <= t.max_steps:
         try:
-            async for result in self._call(
-                self.prompt, temp, think, search, stream, max_steps, step+1,
-                final_prompt, tool_choice=tool_choice, **kwargs): yield result
+            async for result in self._call(self.prompt, step+1, search, tool_choice, **kwargs): yield result
         except ContextWindowExceededError:
             if tmsg is not None:
                 for p in tmsg.content:
                     if len(p.text)>1000: p.text = _cwe_msg + trunc_str(p.text, mx=1000)
-            async for result in self._call(
-                self.prompt, temp, think, search, stream, max_steps, step+1,
-                final_prompt, tool_choice='none', **kwargs): yield result
+            async for result in self._call(self.prompt, step+1, search, 'none', **kwargs): yield result
 
 # %% ../nbs/07_chat.ipynb #1361515a
 @patch
-@delegates(AsyncChat._call)
+@delegates(acomplete)
 async def __call__(
     self:AsyncChat,
     msg=None,          # Message str, or list of multiple message parts
     temp=None,         # Override temp set on chat initialization
-    think=None,        # Thinking (l,m,h)
+    think=None,        # Thinking effort: l/m/h/x, or the full names
     search=None,       # Override search set on chat initialization (l,m,h)
     stream=False,      # Stream results
-    max_steps=2, # Maximum number of tool calls
+    max_steps=2,       # Maximum number of tool calls
     final_prompt=_final_prompt, # Final prompt when tool calls have ran out
+    initial_body=None, # Extra body fields sent with the first request only; tool-loop continuations use the standard payload
     return_all=False,  # Returns all intermediate ModelResponses if not streaming and has tool calls
+    tool_choice=None,  # Force ('required'/a tool name) or disable ('none') tool use
+    max_tokens=None,   # Response token limit (default: the model's maximum)
+    n_workers=8,       # Max concurrent tool executions
+    pause=0.001,       # Pause between tool submissions
+    tc_timeout=7200,   # Per-tool-call timeout in seconds
     **kwargs
 ):
+    self.response_id,self._response_hist_idx = None,0
     self.use = UsageStats()
     self._turn_start = len(self.hist)
-    result_gen = self._call(msg, temp, think, search, stream, max_steps, 1, final_prompt, **kwargs)
+    self.turn_opts = dict(temp=temp, think=think, stream=stream, max_steps=max_steps, final_prompt=final_prompt,
+        max_tokens=max_tokens, n_workers=n_workers, pause=pause, tc_timeout=tc_timeout)
+    result_gen = self._call(msg, 1, search, tool_choice, initial_body, **kwargs)
     if stream or return_all: return result_gen
     async for res in result_gen: pass
     return res # normal chat behavior only return last msg
@@ -406,7 +425,7 @@ _lang2tool = dict(py='python', bash='bash')
 def _active_fence_langs(tool_schemas):
     "Return set of active fence langs whose mapped tool is registered"
     if not tool_schemas: return set()
-    names = {nested_idx(t, 'function', 'name') for t in tool_schemas}
+    names = {fs[0] for t in tool_schemas if (fs:=fn_schema(t))}
     return {lang for lang, tname in _lang2tool.items() if tname in names}
 
 # %% ../nbs/07_chat.ipynb #72274cdc
@@ -415,7 +434,7 @@ async def run_fence_tool(lang, code, ns):
     tname = _lang2tool[lang]
     arg = dict(code=code) if lang == 'py' else dict(cmd=code)
     res = _mk_tool_result(await call_func_async(tname, arg, ns=ns, raise_on_err=False))
-    return mk_result_fence(trunc_str(str(res)))
+    return mk_result_fence(trunc_str(tool_text(res)))
 
 # %% ../nbs/07_chat.ipynb #740ee3a4
 class FenceToolCallback(ChatCallback):