python-fastllm 0.0.58__py3-none-any.whl → 0.0.60__py3-none-any.whl

fastllm/__init__.py

@@ -2,4 +2,4 @@
 
 - `fastllm.responses`: Provider-independent Responses resources and streaming over FastLLM"""
 
-__version__ = "0.0.58"
+__version__ = "0.0.60"

fastllm/_modidx.py

@@ -22,6 +22,8 @@ d = { 'settings': { 'branch': 'main',
             'fastllm.anthropic': { 'fastllm.anthropic._add_cache_control': ('anthropic.html#_add_cache_control', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic._ant_cc': ('anthropic.html#_ant_cc', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic._ant_part_type': ('anthropic.html#_ant_part_type', 'fastllm/anthropic.py'),
+                                   'fastllm.anthropic._clear_cache_control': ( 'anthropic.html#_clear_cache_control',
+                                                                               'fastllm/anthropic.py'),
                                    'fastllm.anthropic._sanid': ('anthropic.html#_sanid', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic._url_cite': ('anthropic.html#_url_cite', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic.acollect_stream': ('anthropic.html#acollect_stream', 'fastllm/anthropic.py'),
@@ -140,7 +142,8 @@ d = { 'settings': { 'branch': 'main',
                                'fastllm.codex.main': ('codex.html#main', 'fastllm/codex.py'),
                                'fastllm.codex.mk_jwt': ('codex.html#mk_jwt', 'fastllm/codex.py'),
                                'fastllm.codex.token_expired': ('codex.html#token_expired', 'fastllm/codex.py')},
-            'fastllm.gemini': { 'fastllm.gemini._fn_calls': ('gemini.html#_fn_calls', 'fastllm/gemini.py'),
+            'fastllm.gemini': { 'fastllm.gemini._fn_call': ('gemini.html#_fn_call', 'fastllm/gemini.py'),
+                                'fastllm.gemini._fn_calls': ('gemini.html#_fn_calls', 'fastllm/gemini.py'),
                                 'fastllm.gemini._gem_filter_sch': ('gemini.html#_gem_filter_sch', 'fastllm/gemini.py'),
                                 'fastllm.gemini._gem_part_type': ('gemini.html#_gem_part_type', 'fastllm/gemini.py'),
                                 'fastllm.gemini._url_cite': ('gemini.html#_url_cite', 'fastllm/gemini.py'),
@@ -315,7 +318,9 @@ d = { 'settings': { 'branch': 'main',
                                    '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._server_call': ('responses.html#_server_call', 'fastllm/responses.py'),
                                    'fastllm.responses._text_content': ('responses.html#_text_content', 'fastllm/responses.py'),
+                                   'fastllm.responses._visible_parts': ('responses.html#_visible_parts', '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/acomplete.py

@@ -1,4 +1,4 @@
-"""A high level unified function make api calls"""
+"""A unified async API for model completions and streaming"""
 
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/06_acomplete.ipynb.
 

fastllm/anthropic.py

@@ -1,3 +1,5 @@
+"""Translate Anthropic Messages API requests, responses, and streams to and from fastllm's shared message types, with tool replay, media, and prompt caching"""
+
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/04_anthropic.ipynb.
 
 # %% auto #0
@@ -16,7 +18,7 @@ from fasttransport.errors import api_error_from_event
 
 from .types import *
 from aidialog.msg_parts import (MdStr, Part, PartType, mk_part, Msg, Completion, Text, Thinking, ToolUse, ToolResult, tool_text,
-                                InputImage, InputAudio, InputVideo, InputFile, data_url)
+    InputImage, InputAudio, InputVideo, InputFile, data_url)
 from .streaming import *
 from .streaming import mk_acollect_stream
 
@@ -44,8 +46,8 @@ def norm_usage(resp):
     pt = int(usg.get("input_tokens", 0) or 0) + cached + cache_creation
     ct = int(usg.get("output_tokens", 0) or 0)
     return Usage(prompt_tokens=pt, completion_tokens=ct, total_tokens=pt + ct,
-                 cached_tokens=cached, cache_creation_tokens=cache_creation, reasoning_tokens=0, raw=usg,
-                 search_queries=int(nested_idx(usg, 'server_tool_use', 'web_search_requests') or 0))
+        cached_tokens=cached, cache_creation_tokens=cache_creation, reasoning_tokens=0, raw=usg,
+        search_queries=int(nested_idx(usg, 'server_tool_use', 'web_search_requests') or 0))
 
 def finalize_usage(usg, parts):
     "Split reasoning tokens out of `output_tokens`: the reported `thinking_tokens`, else an estimate from the thinking text."
@@ -110,7 +112,9 @@ def norm_tr_parts(content):
         if typ=='text': parts.append(Text(b.get('text',''), raw=b))
         elif typ=='image':
             s = b['source']
-            parts.append(InputImage(f"data:{s['media_type']};base64,{s['data']}", mime=s['media_type'], raw=b))
+            if s['type']=='url': parts.append(InputImage(s['url'], raw=b))
+            elif s['type']=='base64': parts.append(InputImage(f"data:{s['media_type']};base64,{s['data']}", mime=s['media_type'], raw=b))
+            else: raise ValueError(f"Unsupported Anthropic image source type: {s['type']!r}")
         else: parts.append(mk_part(**b))
     return parts
 
@@ -238,13 +242,11 @@ def denorm_reasoning(v):
 # %% ../nbs/04_anthropic.ipynb #8fa9fbb8
 def denorm_web_search(v):
     "Map canonical web_search_options to Anthropic hosted web_search tool."
-    _max_uses = {"low": 1, "medium": 5, "high": 10}
+    _max_uses = dict(low=1, medium=5, high=10)
     t = {"type": "web_search_20250305", "name": "web_search"}
     if (typ := (v or {}).get("type")): t["type"] = typ
-    if (s := (v or {}).get("search_context_size")):
-        t["max_uses"] = _max_uses.get(s, 5)
-    if (u := (v or {}).get("user_location", {}).get("approximate")):
-        t["user_location"] = {"type": "approximate", **u}
+    if (s := (v or {}).get("search_context_size")): t["max_uses"] = _max_uses.get(s, 5)
+    if (u := (v or {}).get("user_location", {}).get("approximate")): t["user_location"] = {"type": "approximate", **u}
     return t
 
 # %% ../nbs/04_anthropic.ipynb #6b485275
@@ -269,12 +271,12 @@ def denorm_user(m:Msg):
 def denorm_image(p, max_sz=None):
     if (b64:=data_url(p.text)):
         data = resize_b64(b64[1], max_sz) if max_sz else b64[1]
-        return {"type": "image", "source": {"type": "base64", "media_type": b64[0], "data": data}}
+        return {"type": "image", "source": dict(type="base64", media_type=b64[0], data=data)}
     return {"type": "image", "source": {"type": "url", "url": p.text}}
 
 # %% ../nbs/04_anthropic.ipynb #fc6bbdfc
 def denorm_file(p):
-    if (b64:=data_url(p.text)): return {"type": "document", "source": {"type": "base64", "media_type": b64[0], "data": b64[1]}}
+    if (b64:=data_url(p.text)): return {"type": "document", "source": dict(type="base64", media_type=b64[0], data=b64[1])}
     return {"type": "document", "source": {"type": "url", "url": p.text}}
 
 # %% ../nbs/04_anthropic.ipynb #37b63cc2
@@ -303,15 +305,21 @@ def _add_cache_control(
     return msg
 
 # %% ../nbs/04_anthropic.ipynb #6bc52ef5
+def _clear_cache_control(obj):
+    "Clear canonical cache marks from a message or part."
+    if isinstance(obj, Msg):
+        for p in obj.content: _clear_cache_control(p)
+    elif isinstance(obj, Part): obj.cache_control = None
+
 def apply_cache_idxs(
     msgs,            # Canonical Msgs to mark
     cache_idxs=[-1], # Breakpoint idxs into `msgs` (tool-role msgs excluded); 0 is `sp` when given
     sp=None,         # System prompt: str, Msg, or Part
     ttl=None         # Cache TTL: '5m' (default) or '1h'
 ):
-    "Strip all cache breakpoints from `msgs`, then mark `cache_idxs`; returns `sp`, marked if 0 is included"
-    for m in msgs:
-        for p in m.content: p.cache_control = None
+    "Replace cache breakpoints in `msgs` and `sp`, then return the system prompt."
+    for m in msgs: _clear_cache_control(m)
+    _clear_cache_control(sp)
     if sp:
         if 0 in cache_idxs:
             if isinstance(sp, str): sp = Text(sp)
@@ -335,10 +343,8 @@ def mk_payload(msgs, model, **kwargs):
     if tools:=kwargs.get('tools'):          payload['tools'] = denorm_tool_schs(tools)
     if tchc:=kwargs.get('tool_choice'):     payload['tool_choice'] = denorm_tool_choice(tchc)
     if thk:=kwargs.get('reasoning_effort'): payload.update(denorm_reasoning(thk))
-    if (wopts:=kwargs.get('web_search_options')) is not None: 
-        payload.setdefault('tools', []).append(denorm_web_search(wopts))
-    if (temp:=kwargs.get('temperature')) is not None: 
-        payload['temperature'] = temp
+    if (wopts:=kwargs.get('web_search_options')) is not None: payload.setdefault('tools', []).append(denorm_web_search(wopts))
+    if (temp:=kwargs.get('temperature')) is not None: payload['temperature'] = temp
     return payload
 
 # %% ../nbs/04_anthropic.ipynb #60d52c1f
@@ -367,5 +373,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, raw_msg=raw_msg, collate_raw=collate_raw, acollect_stream=acollect_stream, mk_payload=mk_payload,
-    cost=cost, get_hdrs=get_hdrs,
-    endpoint='/v1/messages')
+    cost=cost, get_hdrs=get_hdrs, endpoint='/v1/messages')

fastllm/chat.py

@@ -1,4 +1,4 @@
-"""High level chat api for fastllm similar to lisette"""
+"""A high-level chat API for fastllm, similar to Lisette"""
 
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/07_chat.ipynb.
 
@@ -112,9 +112,12 @@ _cwe_msg = "ContextWindowExceededError: Do no more tool calls and complete your
 
 # %% ../nbs/07_chat.ipynb #05c20a94
 def search_count(r):
-    if cnt := nested_idx(r.usage.raw, 'server_tool_use', 'web_search_requests'): return cnt # Anthropic
-    if cnt := nested_idx(r.usage.raw, 'server_tool_use', 'google_search'): return cnt # Gemini
-    if cnt := nested_idx(r.usage.raw, 'web_search_requests'): return cnt # streaming with `include_usage`
+    raw = r.usage.raw or {}
+    if (cnt := raw.get('web_search_requests')) is not None: return cnt # host aggregate
+    if cnt := r.usage.search_queries: return cnt
+    legacy = raw.get('server_tool_use') or {}
+    if (cnt := legacy.get('web_search_requests')) is not None: return cnt # Anthropic
+    if (cnt := legacy.get('google_search')) is not None: return cnt # Gemini
     return 0
 
 # %% ../nbs/07_chat.ipynb #61395e0d
@@ -288,8 +291,9 @@ async def _call(self:AsyncChat, msg=None, step=1, search=None, tool_choice=None,
     async for o in self._call_cbs('after_msgs'): yield o
 
     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
+    kw = self.turn_kwargs
+    if initial_body: kw = merge(kw, dict(xtra_body=merge(kw.get('xtra_body'), initial_body)))
     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,
@@ -413,7 +417,7 @@ class StopReasonCallback(ChatCallback):
         action,msg = _handle_stop_reason(self.turn_res)
         if action != 'warning': return
         add_warning(self.chat.turn_res, msg)
-        if self.stream: yield dict(text=f"warning: {msg}\n\n")
+        if self.stream: yield Text(f'\n\nwarning: {msg}\n\n')
 
 # %% ../nbs/07_chat.ipynb #aa7630b2
 _lang2tool = dict(py='python', bash='bash')
@@ -493,11 +497,11 @@ defaults.chat_callbacks = [FenceToolCallback, ToolReminderCallback, StopReasonCa
 
 # %% ../nbs/07_chat.ipynb #ead4b56d
 class StreamAccum:
-    "Accumulate a formatted stream: append each item's `formatted`, swap in `chat.full()` on `Refresh`"
+    "Accumulate formatted parts; refresh from `chat.full()` on `Refresh` or `Completion`"
     def __init__(self, chat=None, mx=2000): self.chat,self.mx,self.txt,self.last = chat,mx,'',None
     def __call__(self, o):
         "Feed one stream item; True if the display text changed"
-        if isinstance(o, Refresh):
+        if isinstance(o, (Refresh, Completion)):
             if self.chat is None: return False
             self.txt,self.last = self.chat.full(mx=self.mx)+'\n\n',None
         elif f := getattr(o, 'formatted', ''):
@@ -509,7 +513,7 @@ class StreamAccum:
 
 # %% ../nbs/07_chat.ipynb #944bcd25
 async def adisplay_stream(rs, chat=None, mx=2000):
-    "Use IPython.display to markdown display the response stream, refreshing from `chat.full()` on `Refresh`."
+    "Display a stream as Markdown, refreshing from `chat.full()` on `Refresh` or `Completion`."
     try: from IPython.display import display, Markdown
     except ModuleNotFoundError: raise ModuleNotFoundError("This function requires ipython. Please run `pip install ipython` to use.")
     acc,h = StreamAccum(chat, mx=mx), display(Markdown(' '), display_id=True)

fastllm/gemini.py

@@ -1,3 +1,5 @@
+"""Translate Gemini generateContent requests, responses, and streams to and from fastllm's shared message types, including tools, thought signatures, search grounding, and media"""
+
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/05_gemini.ipynb.
 
 # %% auto #0
@@ -16,7 +18,7 @@ from fasttransport.errors import api_error_from_event
 
 from .types import *
 from aidialog.msg_parts import (MdStr, Part, PartType, Msg, Completion, Text, Thinking, ToolUse, ToolResult, tool_text,
-                                InputImage, InputAudio, InputVideo, InputFile, sys_text, part_txt, data_url, url_mime)
+    InputImage, InputAudio, InputVideo, InputFile, sys_text, part_txt, data_url, url_mime)
 from .streaming import *
 from .streaming import mk_acollect_stream
 
@@ -41,9 +43,12 @@ def grounding(cand):
     return cites, call
 
 # %% ../nbs/05_gemini.ipynb #48de3125
-def _fn_calls(parts):
-    return [ToolUse(id=fc.get("id", f"call_{i}"), name=fc.get("name", ""), arguments=fc.get("args") or {}, raw={k:v for k,v in p.items() if k != "functionCall"})
-        for i,p in enumerate(parts) if (fc := p.get("functionCall"))]
+def _fn_call(p, i):
+    fc = p['functionCall']
+    return ToolUse(id=fc.get("id", f"call_{i}"), name=fc.get("name", ""), arguments=fc.get("args") or {},
+        raw={k:v for k,v in p.items() if k != "functionCall"})
+
+def _fn_calls(parts): return [_fn_call(p, i) for i,p in enumerate(parts) if p.get('functionCall')]
 
 def norm_tool_calls(resp):
     "Tool calls of a response: the `google_search` call its grounding describes, then its `functionCall` parts"
@@ -67,7 +72,7 @@ def norm_usage(resp):
     if call := grounding(cand)[1]: stu['google_search'] = len(call.arguments['queries'] or [1])
     if stu: usg['server_tool_use'] = stu
     return Usage(prompt_tokens=pt, completion_tokens=ct, total_tokens=tt,
-                 cached_tokens=cached, reasoning_tokens=reasoning, search_queries=stu.get('google_search', 0), raw=usg)
+        cached_tokens=cached, reasoning_tokens=reasoning, search_queries=stu.get('google_search', 0), raw=usg)
 
 # %% ../nbs/05_gemini.ipynb #7a8b1f8f
 def norm_finish(resp, tcs=None):
@@ -90,13 +95,11 @@ def norm_parts(resp):
     "Normalize Gemini generateContent response; a search's `toolCall` and `toolResponse` parts give way to the call `grounding` builds"
     c0 = nested_idx(resp, 'candidates', 0) or {}
     cites,call = grounding(c0)
-    tc_map = {tc.id: tc for tc in norm_tool_calls(resp)}
     parts = [call] if call else []
-    for p in nested_idx(c0, 'content', 'parts') or []:
+    for i,p in enumerate(nested_idx(c0, 'content', 'parts') or []):
         if 'toolCall' in p or 'toolResponse' in p: continue
         typ = _gem_part_type(p)
-        if typ == PartType.tool_use:
-            if tc := tc_map.get(p['functionCall'].get('id')): parts.append(tc)
+        if typ == PartType.tool_use:      parts.append(_fn_call(p, i))
         elif typ == PartType.thinking:    parts.append(Thinking(p.get("text",""), raw=p))
         elif typ == PartType.tool_result: parts.append(ToolResult(text=p.get("text",""), raw=p))
         else:                             parts.append(Text(p.get("text",""), raw=p))
@@ -175,15 +178,20 @@ def denorm_msgs(msgs:list[Msg]):
     return res
 
 # %% ../nbs/05_gemini.ipynb #adb525db
-_valid_gemini_sch = {'type', 'format', 'title', 'description', 'nullable', 'default',
-    'items', 'minItems', 'maxItems', 'enum', 'properties', 'propertyOrdering',
-    'required', 'minProperties', 'maxProperties', 'minimum', 'maximum',
-    'minLength', 'maxLength', 'pattern', 'example', 'anyOf'}
+_valid_gemini_sch = {'type', 'format', 'title', 'description', 'nullable', 'default', 'items', 'minItems', 'maxItems', 'enum', 'properties',
+    'propertyOrdering', 'required', 'minProperties', 'maxProperties', 'minimum', 'maximum', 'minLength', 'maxLength', 'pattern', 'example',
+    'anyOf'}
 
 def _gem_filter_sch(s):
     if isinstance(s, list): return [_gem_filter_sch(x) for x in s]
     if not isinstance(s, dict): return s
-    return {k: _gem_filter_sch(v) for k,v in s.items() if k in _valid_gemini_sch}
+    res = {}
+    for k,v in s.items():
+        if k not in _valid_gemini_sch: continue
+        if k == 'properties': res[k] = {name:_gem_filter_sch(prop) for name,prop in v.items()}
+        elif k in ('items', 'anyOf'): res[k] = _gem_filter_sch(v)
+        else: res[k] = v
+    return res
 
 def denorm_tool_schs(tools):
     "Convert canonical tools to Gemini format."
@@ -192,8 +200,7 @@ def denorm_tool_schs(tools):
         fn = fn_schema(t)
         if fn is None: other.append(t); continue
         name, desc, params = fn
-        params = {k:v for k,v in params.items() if k in _valid_gemini_sch}
-        params['properties'] = {k:_gem_filter_sch(v) for k,v in params['properties'].items()}
+        params = _gem_filter_sch(params)
         fn_decls.append(dict(name=name, description=desc, parameters=params))
     out = other[:]
     if fn_decls: out.insert(0, dict(functionDeclarations=fn_decls))
@@ -214,13 +221,11 @@ _gem_think_levels  = dict(minimal='low', low='low', medium='medium', high='high'
 
 def denorm_reasoning(v, model=''):
     "Map canonical reasoning_effort to Gemini thinkingConfig (uses thinkingLevel for Gemini 3+)."
-    err = ValueError(f"Invalid reasoning effort for Gemini: {v}, accepted string values are: {list(_gem_think_budgets)} and dicts are passthrough")
-    if v is None: return None
-    elif isinstance(v, dict): return v
-    elif isinstance(v, str) and v in _gem_think_budgets:
-        # defaults to includeThoughts same as litellm
-        if 'gemini-3' in model: return {'thinkingLevel': _gem_think_levels.get(v, 'medium'), 'includeThoughts': True}
-        return {'thinkingBudget': _gem_think_budgets.get(str(v).lower(), 1024), 'includeThoughts': True}
+    if v is None or isinstance(v, dict): return v
+    if not isinstance(v, str) or v not in _gem_think_budgets:
+        raise ValueError(f"Invalid reasoning effort for Gemini: {v!r}; expected one of {list(_gem_think_budgets)}, a dict, or None")
+    if 'gemini-3' in model: return {'thinkingLevel': _gem_think_levels[v], 'includeThoughts': True}
+    return {'thinkingBudget': _gem_think_budgets[v], 'includeThoughts': True}
 
 # %% ../nbs/05_gemini.ipynb #8fa9fbb8
 def denorm_web_search(v): return {"googleSearch": {}}
@@ -325,15 +330,7 @@ def cost(usage, m):
     return cost
 
 # %% ../nbs/05_gemini.ipynb #f7c0b989
-api_ns = dict(norm_tool_calls=norm_tool_calls,
-                norm_parts=norm_parts,
-                norm_finish=norm_finish,
-                norm_usage=norm_usage,
-                acollect_stream=acollect_stream,
-                raw_msg=raw_msg,
-                collate_raw=collate_raw,
-                mk_payload=mk_payload,
-                cost=cost,
-                get_hdrs=get_hdrs,
-                endpoint=endpoint)
+api_ns = dict(norm_tool_calls=norm_tool_calls, norm_parts=norm_parts, norm_finish=norm_finish, norm_usage=norm_usage,
+    acollect_stream=acollect_stream, raw_msg=raw_msg, collate_raw=collate_raw, mk_payload=mk_payload, cost=cost, get_hdrs=get_hdrs,
+    endpoint=endpoint)
 api_registry.register('gemini', **api_ns)

fastllm/openai_chat.py

@@ -1,3 +1,5 @@
+"""Translate Chat Completions requests, responses, and streams to and from fastllm's shared message types"""
+
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/03_oai_chat.ipynb.
 
 # %% auto #0

fastllm/openai_responses.py

@@ -1,3 +1,5 @@
+"""Translate Responses API payloads, completed responses, and stream events to and from fastllm's shared message types"""
+
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/02_oai_responses.ipynb.
 
 # %% auto #0
@@ -65,7 +67,7 @@ def norm_finish(resp, tcs=None):
 
 # %% ../nbs/02_oai_responses.ipynb #bbfb99b9
 def search_hits(parts):
-    "OpenAI reports no result for a hosted search, so a server call's empty `text` becomes the message's cited sources, one `title: url` line each"
+    "Fill empty server-tool results with the message's cited sources as `title: url` lines"
     hits = {c['url']: c.get('title', '') for p in parts if isinstance(p, Text) for c in p.citations or [] if c.get('url')}
     for p in parts:
         if isinstance(p, ToolUse) and p.server and not p.text: p.text = MdStr('\n'.join(f"{t}: {u}" for u,t in hits.items()))
@@ -77,9 +79,7 @@ def norm_parts(resp):
     for item in resp["output"]:
         if (typ:=item["type"]) == "message":
             for c in item["content"]:
-                if (ctyp := c["type"]) == "output_text":
-                    c['citations'] = c.pop('annotations', [])
-                    parts.append(Text(c['text'], citations=c['citations'], raw=c))
+                if (ctyp := c["type"]) == "output_text": parts.append(Text(c['text'], citations=list(c.get('annotations') or []), raw=c))
                 elif ctyp == "refusal": parts.append(Refusal(c['refusal'], raw=c))
         elif typ == "reasoning":
             for s in item["summary"]: parts.append(Thinking(s['text'], raw=item))
@@ -88,7 +88,7 @@ def norm_parts(resp):
 
 # %% ../nbs/02_oai_responses.ipynb #2aaab962
 def raw_msg(resp):
-    "The output items as the API sent them"
+    "Return the response output list for assistant replay, without copying"
     return resp['output']
 
 # %% ../nbs/02_oai_responses.ipynb #ef2d19f3
@@ -282,6 +282,7 @@ def cost(usage, m):
 # %% ../nbs/02_oai_responses.ipynb #2efda2a1
 def fix_payload(payload, model, vendor_name):
     "Apply vendor request quirks to a built payload."
+    if model == 'gpt-6-astra': payload.pop('temperature', None)
     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
@@ -289,6 +290,5 @@ def fix_payload(payload, model, vendor_name):
 # %% ../nbs/02_oai_responses.ipynb #07114b55
 api_ns = dict(norm_tool_calls=norm_tool_calls, norm_parts=norm_parts, norm_finish=norm_finish, norm_usage=norm_usage,
     supports_previous_response_id=True, raw_msg=raw_msg, collate_raw=collate_raw, acollect_stream=acollect_stream, mk_payload=mk_payload,
-    cost=cost, get_hdrs=get_hdrs, fix_payload=fix_payload,
-    endpoint='/responses')
+    cost=cost, get_hdrs=get_hdrs, fix_payload=fix_payload, endpoint='/responses')
 api_registry.register('openai', **api_ns)

fastllm/responses.py

@@ -1,12 +1,12 @@
 """Provider-independent Responses resources and streaming over FastLLM
 
-`response_input` converts a plain prompt or standard input-item array to canonical messages. System and developer messages become provider instructions; adjacent function outputs remain one tool message so a parallel batch reaches the next model turn together.
+`response_input` accepts a prompt string or an input-item array. It returns `(messages, instructions)`. System and developer text goes in the instructions; the remaining items become shared messages.
 
-FastLLM completions become ordinary assistant-message and function-call items. Call ids are normalized before the canonical history is retained, so a later tool result always refers to the same id the client saw.
+`normalize_call_ids` supplies missing client call IDs before we retain the history. Later tool results can refer to the same IDs that the client received.
 
-`ResponseState` is the complete provider-independent continuation value. A host may store it under any ownership and expiry policy. When a provider id exists, the next turn sends only new items; otherwise it replays canonical history.
+`ResponseState` holds the public ID, model, full message history, and optional provider response ID. The host can store it under its own ownership and expiry rules. A provider ID lets the next call send just the new messages; without one, it needs the retained history.
 
-Every request is streamed. `_ResponseStream` only tracks the standard event grammar for one inference; it contains no provider, persistence, or billing policy."""
+FastLLM calls stream internally. The helpers here turn their parts into Responses SSE frames; they don't decide storage, ownership, or billing policy."""
 
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/06a_responses.ipynb.
 
@@ -361,13 +361,25 @@ def done_events(self:_ResponseStream, comp):
         if isinstance(part, ToolUse) and part.server:
             events.append(self.event('response.output_item.done', output_index=self.next_index, item=server_call_item(part)))
             self.next_index += 1
-    for i,tc in enumerate(comp.tool_calls):
+    client_calls = [tc for tc in comp.tool_calls if not tc.server]
+    for i,tc in enumerate(client_calls):
         if not tc.id and i < len(self.streamed_call_ids): tc.id = self.streamed_call_ids[i]
         tc._response_item_id = self.tool_item_ids.get(tc.id)
     for part in comp.message.content:
         if isinstance(part, Text): part._response_item_id = self.message_id
     return events
 
+# %% ../nbs/06a_responses.ipynb #04a20345
+def _server_call(result):
+    "A public server call with the host's completed result."
+    return ToolUse(id=result.id, name=result.name, arguments=result.arguments, server=True, text=result.text)
+
+def _visible_parts(parts, results):
+    "Replace completed host calls without changing the provider's parts."
+    completed = {r.id:r for r in results}
+    return [_server_call(completed[p.id]) if isinstance(p, ToolUse) and p.id in completed else p for p in parts]
+
+
 # %% ../nbs/06a_responses.ipynb #e10c928b
 @patch
 async def events(self:AsyncResponses, turn, finalize=None, stream=None):
@@ -385,11 +397,11 @@ async def events(self:AsyncResponses, turn, finalize=None, stream=None):
             results = await self.server_results(turn, comp)
             if not results or len(results) < len(comp.tool_calls): break
             texts += [p for p in comp.message.content if isinstance(p, Text) or (isinstance(p, ToolUse) and p.server)]
-            texts += [ToolUse(id=r.id, name=r.name, arguments=r.arguments, server=True, text=r.text) for r in results]
+            texts += [_server_call(r) for r in results]
             turn = self.server_turn(turn, comp, results)
         next_state = self.state(turn, comp, results)
         comp = copy.copy(comp)
-        comp.message,comp.usage = Msg('assistant', texts + comp.message.content),usage
+        comp.message,comp.usage = Msg('assistant', texts + _visible_parts(comp.message.content, results)),usage
         for event in state.done_events(comp): yield event
         response = response_object(first.id, first.body, comp, first.previous.id if first.previous else None, first.created_at)
         if finalize and (extra := await finalize(next_state, comp)): response['usage'].update(extra)

fastllm/streaming.py

@@ -184,7 +184,6 @@ async def mk_acollect_stream(it, index_fn, model=None, api_name=None, vendor_nam
     if stop: fin = FinishReason.stop
     fin = FinishReason.tool_calls if fin==FinishReason.stop and any(~L(tcs).attrgot('server')) else fin # recheck tool calls post collation
     # tool calls and non-anthropic citations are yielded at the end
-    yield Completion(model,
-            message=Msg(role="assistant", content=parts, raw=api_registry[api_name].collate_raw(deltas) if api_name else None),
-            finish_reason=fin, usage=usg, api_name=api_name, vendor_name=vendor_name,
-            raw={'deltas':deltas})
+    (((((((yield Completion(model,
+        message=Msg(role='assistant', content=parts, raw=api_registry[api_name].collate_raw(deltas) if api_name else None),
+        finish_reason=fin, usage=usg, api_name=api_name, vendor_name=vendor_name, raw={'deltas': deltas}))))))))

fastllm/types.py

@@ -7,7 +7,7 @@ __all__ = ['FinishReason', 'api_registry', 'model_prices_url', 'sample_img_url',
            'sonn', 'sonn5', 'opus46', 'opus48', 'opus', 'opus5', 'fable', 'fable5', 'fable51', 'gpt54', 'gpt54m',
            'gpt55', 'codex54', 'codex54m', 'codex55', 'codex53spark', 'model_info_registry', 'modern_llm',
            'effort_codes', 'deepseek_v4_common', 'deepseek_v4_flash_prices', 'mimo_v25_common', 'codex_pricing', 'sol',
-           'terra', 'luna', 'gpt56s', 'Usage', 'APIRegistry', 'mk_completion', 'fn_schema', 'payload_kwargs',
+           'terra', 'luna', 'gpt56s', 'astra', 'Usage', 'APIRegistry', 'mk_completion', 'fn_schema', 'payload_kwargs',
            'provider_req', 'get_api_key', 'wrap_typed', 'unwrap_typed', 'resize_b64', 'model_prices_meta',
            'infer_api_name', 'get_model_meta', 'register_model_info', 'get_model_info', 'effort_code', 'effort_levels',
            'resolve_effort', 'get_model_pricing', 'approx_pricing', 'is_deepseek_peak_hour', 'price_tier', 'tier_rate']
@@ -136,11 +136,11 @@ _typed_re = re.compile(r'^𝍁(\w+)𝍁(.+)$', re.S)
 _typed_strs = {c.__name__: c for c in (StopResponse, FullResponse)}
 
 def wrap_typed(s):
-    "Mark `s` with a `𝍁TypeName𝍁` prefix when it is a `str` subclass, so the type survives a plain-string wire"
+    "Prefix a `str` subclass with `𝍁TypeName𝍁` for transmission as plain text"
     return s if type(s) is str else f'𝍁{type(s).__name__}𝍁{s}'
 
 def unwrap_typed(s):
-    "Rebuild the named `str` subclass from a `𝍁`-marked string; unknown names get a minted ephemeral type"
+    "Decode a `𝍁TypeName𝍁` prefix, creating a `str` subclass for an unknown name"
     if not (m := _typed_re.match(s)): return s
     nm,body = m.groups()
     return _typed_strs.setdefault(nm, type(nm, (str,), {}))(body)
@@ -317,11 +317,16 @@ for model in (haik45, sonn45, sonn46, sonn5, opus46, opus48, opus5, fable5, fabl
 
 # %% ../nbs/00_types.ipynb #bb0c4c2a
 sol,terra,luna = gpt56s = 'gpt-5.6-sol gpt-5.6-terra gpt-5.6-luna'.split()
+astra = 'gpt-6-astra'
+for model in (*gpt56s, astra): register_model_info(model, 'openai', base=model, max_input_tokens=272_000)
+
 # Codex serves only the suffixed names; bare `gpt-5.6` is rejected with a ChatGPT account.
-# Its window is smaller than the API's: 371,331 input tokens is accepted and 371,981 is not, on all three.
+# Its window accepts 371,331 input tokens and rejects 371,981, on all three.
 for model in gpt56s:
     register_model_info(model, 'codex', base=model, base_vendor_name='openai', max_input_tokens=371_000, **codex_pricing)
     _flat_rates('codex', model)
+register_model_info(astra, 'codex', base=astra, base_vendor_name='openai', **codex_pricing)
+_flat_rates('codex', astra)
 
 # %% ../nbs/00_types.ipynb #24cc47ec
 def get_model_pricing(mn, vendor_name, million=True):

python_fastllm-0.0.60.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: python-fastllm
+Version: 0.0.60
+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.27
+Requires-Dist: fasttransport>=0.0.2
+Requires-Dist: pillow
+
+# fastllm
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+`fastllm` provides a common async interface for Anthropic, OpenAI Responses and Chat, Gemini, and OpenAI-compatible providers such as Kimi. Define messages and tools in a shared format and call `acomplete`. Select the model and, where needed, its provider without rewriting the conversation or tool loop. Supported features vary by provider.
+
+`AsyncResponses` provides a streaming Responses API interface over the same providers. It translates input items and events and keeps a canonical `ResponseState` between turns. For transports without provider continuation ids, it replays that state automatically.
+
+## Install
+
+Run `pip install python-fastllm` or clone from github and install locally.
+
+## Setup
+
+``` python
+from aidialog.msg_parts import Msg, Part, Text, Thinking, ToolUse, InputImage, mk_tool_res_msg, Completion
+from fastllm.acomplete import acomplete
+from fastllm.types import sample_img_url, sample_doms
+import asyncio, json
+```
+
+``` python
+def user(text): return Msg(role='user', content=[Text(text)])
+
+async def stream(msgs, model, max_think=0, **kw):
+    "Print streamed parts and return the final Completion; limit printed thinking deltas with max_think."
+    cnt = 0
+    async for o in await acomplete(msgs, model, stream=True, **kw):
+        if not isinstance(o, Part): continue
+        if isinstance(o, Thinking):
+            cnt += 1
+            if cnt > max_think: continue
+        print(o.formatted, end='', flush=True)
+    print()
+    return o
+```
+
+``` python
+mtok = 1024
+```
+
+## Chat across providers
+
+Use the same `acomplete` interface with Claude, GPT, Gemini, or Kimi. Set `model` and any provider-specific routing arguments:
+
+``` python
+models = [
+    ('claude-sonnet-5', {}),
+    ('gpt-4o-mini', {}),
+    ('models/gemini-3-flash-preview', {}),
+    ('accounts/fireworks/models/kimi-k3', dict(vendor_name='fireworks_ai'))
+]
+for name, kw in models:
+    r = await acomplete([user("Translate 'hello' into French. Return only the translation.")],
+                       model=name, max_tokens=mtok, **kw)
+    text = ''.join(p.text for p in r.message.content if isinstance(p, Text))
+    print(f"{name}: {text.strip()}")
+```
+
+    claude-sonnet-5: Bonjour
+    gpt-4o-mini: Bonjour
+    models/gemini-3-flash-preview: Bonjour
+    accounts/fireworks/models/kimi-k3: Bonjour
+
+## System prompts
+
+Pass `system` to supply a system prompt. `fastllm` translates it to the provider’s field: Anthropic `system`, OpenAI Responses `instructions`, or Gemini `system_instruction`.
+
+``` python
+sys = "You are a pirate chef. Always respond in pirate speak and mention food. Use one short sentence."
+
+print("Claude: ", end='')
+r = await stream([user("What should I do today?")], model='claude-sonnet-5', system=sys, max_tokens=mtok)
+
+print("Gemini: ", end='')
+r = await stream([user("What should I do today?")], model='models/gemini-3-flash-preview', system=sys, max_tokens=mtok)
+```
+
+    Claude: Arrr, chart a course fer the galley and cook up a hearty stew, matey!
+    Gemini: Sharpen yer cutlass and feast on spicy shark stew, ye scurvy dog!
+
+## Tool calling
+
+Define tools in the shared schema. `fastllm` translates it to the provider’s tool format. This example handles a tool request, adds the result to the history, and continues the conversation:
+
+``` python
+tools = [{"type": "function", "function": {
+    "name": "get_weather",
+    "description": "Get current weather for a city",
+    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}
+}}]
+
+msgs = [user("What's the weather in Paris?")]
+r1 = await stream(msgs, model='claude-sonnet-5', tools=tools, max_tokens=mtok)
+print("Tool calls:", r1.tool_calls)
+```
+
+    - ⏳ `get_weather(city="Paris")` ⏳
+
+    Tool calls: [ToolUse(raw={'caller': {'type': 'direct'}}, cache_control=None, id='toolu_01XacBpJHnsjtPWJWr55nA2m', name='get_weather', arguments={'city': 'Paris'}, server=False, text=None)]
+
+``` python
+msgs += [r1.message, mk_tool_res_msg(r1.tool_calls, ['22°C, sunny with light clouds']),
+         user("Should I bring a jacket? Answer in one short sentence.")]
+r2 = await stream(msgs, model='claude-sonnet-5', tools=tools, max_tokens=mtok)
+```
+
+    No, a jacket isn't necessary — it's a mild, sunny 22°C day.
+
+## Tool Choice
+
+Control whether the model must use tools, can’t use tools, or decides on its own:
+
+``` python
+r = await acomplete([user("Hello there!")], model='claude-sonnet-5',
+                    tools=tools, tool_choice='required', max_tokens=mtok)
+print("Required:", [tc.name for tc in r.tool_calls])
+
+r = await acomplete([user("What's the weather?")], model='claude-sonnet-5',
+                    tools=tools, tool_choice='none', max_tokens=mtok)
+print("None:", r.tool_calls)
+```
+
+    Required: ['get_weather']
+    None: []
+
+## Thinking and extended reasoning
+
+Set `reasoning_effort` to `low`, `medium`, or `high` for supported models. The adapters translate these values to provider-specific settings. Reasoning output uses `Thinking` parts; this example prints a short excerpt alongside the answer.
+
+``` python
+print("Claude: ", end='')
+r = await stream([user("What is 127 × 849? Return just the number.")], model='claude-sonnet-4-6',
+                 reasoning_effort='low', max_tokens=8192)
+for p in r.message.content:
+    if isinstance(p, Thinking): print(f"Thinking excerpt: {p.text[:150]}...")
+
+print("Kimi: ", end='')
+r = await stream([user("What is 127 × 849? Return just the number.")],
+                 model='accounts/fireworks/models/kimi-k3', vendor_name='fireworks_ai',
+                 reasoning_effort='low', max_tokens=8192)
+for p in r.message.content:
+    if isinstance(p, Thinking): print(f"Thinking excerpt: {p.text[:150]}...")
+```
+
+    Claude: 107823
+    Thinking excerpt: 127 × 849 = 127 × 800 + 127 × 49 = 101600 + 6223 = 107823...
+    Kimi: 107823
+    Thinking excerpt: 127 × 849 = 107823. Let me verify: 127*800=101600; 127*49=6223; total 107823. Return just number....
+
+## Web Search (Server Tools)
+
+OpenAI’s Responses API supports server-side web search. Server tool calls are normalized alongside regular tool calls:
+
+``` python
+ws_tools = [{"type": "web_search_preview"}]
+r = await acomplete([user("What is the latest Python release? Reply with the version number only.")],
+                    model='gpt-4o-mini', tools=ws_tools, max_tokens=512)
+print("Server tools used:", [tc.name for tc in r.tool_calls if tc.server])
+```
+
+    Server tools used: ['web_search']
+
+## Caching with Anthropic
+
+Set a part’s `cache_control` to request prompt caching. Later requests can reuse eligible cached content. The example prints usage for two calls with the same system prompt:
+
+``` python
+long_ctx = "You are an expert on the solar system. " * 200
+system = Text(long_ctx, cache_control={'type': 'ephemeral'})
+
+r1 = await acomplete([user("What is Jupiter's mass? Answer in one sentence.")],
+                     model='claude-sonnet-5', system=system, max_tokens=mtok)
+print("First call: cache creation tokens", r1.usage.cache_creation_tokens)
+
+r2 = await acomplete([user("What is Saturn's mass? Answer in one sentence.")],
+                     model='claude-sonnet-5', system=system, max_tokens=mtok)
+print("Second call: cache read tokens", r2.usage.cached_tokens)
+```
+
+    First call: cache creation tokens 2204
+    Second call: cache read tokens 2204
+
+## Media inputs
+
+Use `InputImage` with a model that supports images. The example sends the same image message to three providers:
+
+``` python
+img_msg = Msg(role='user', content=[
+    InputImage(sample_img_url),
+    Text("List three visible objects, using nouns only.")
+])
+
+for name, kw in [('claude-sonnet-5', {}), ('gpt-4o-mini', {}), ('models/gemini-3-flash-preview', {})]:
+    print(f"{name}: ", end='')
+    r = await stream([img_msg], model=name, max_tokens=mtok, **kw)
+```
+
+    claude-sonnet-5: Mountains, lake, trees
+    gpt-4o-mini: 1. Mountains  
+    2. Trees  
+    3. Lake
+    models/gemini-3-flash-preview: planks, lake, mountains
+
+The media adapters support the following part types:
+
+| Media part   | Anthropic | OpenAI Responses | OpenAI Chat | Gemini |
+|--------------|-----------|------------------|-------------|--------|
+| `InputImage` | Yes       | Yes              | Yes         | Yes    |
+| `InputAudio` | No        | No               | Yes         | Yes    |
+| `InputVideo` | No        | No               | No          | Yes    |
+| `InputFile`  | Yes       | Yes              | Yes         | Yes    |
+
+Media parts accept a URL or base64 data URL as their `text`. An unsupported combination raises `ValueError`.

python_fastllm-0.0.60.dist-info/RECORD

@@ -0,0 +1,18 @@
+fastllm/__init__.py,sha256=RzCM0b2ATYsYmXlX_uPf0CguuCCIUz7Jl-gj65TszzE,131
+fastllm/_modidx.py,sha256=iyQLdOYLOPp87AmgdFQhL7QUxXMKh-TooHd6swPFuMc,46958
+fastllm/acomplete.py,sha256=2BTlr5ZZFslscSCquXes3OnwrzCmtbPxGCwZtLGdPkY,10788
+fastllm/anthropic.py,sha256=N8gfoDftlH-WFVO3CED4OGTv5qDTDGBHzp4JevgOFss,19347
+fastllm/chat.py,sha256=f92AOIpJipEi3GZPnTKinJvxMU2RLdu_qEKkAUjgtcU,25099
+fastllm/codex.py,sha256=r6auZ8egia83aGkWcF4132AzW4SsBvKeDwg_CxyXj9E,5808
+fastllm/gemini.py,sha256=56C3NJt8WLwx_XUWU-AElyfz_V5Zp2hIGmmkFhjFWn0,17527
+fastllm/model_prices.json,sha256=pa0j96LZgklYii8howX443QbukUP1iFr3lBcucS-6Yo,2133018
+fastllm/openai_chat.py,sha256=yGtUQbN8UBzMwDkBUALLWdlxYOcHWX78ZT2Ic8FCXWg,12489
+fastllm/openai_responses.py,sha256=n0uzAULex61rXNWuzvxSBV9-qHpqSQfl-7KBNk_GO6w,15440
+fastllm/responses.py,sha256=k5D3YS8zgvUBpk_qADPtvVD9CUOWl4iej_0qvi-GuVs,23166
+fastllm/streaming.py,sha256=dQ7ZFc4JEtPanoKXizww91rmYXTODTisQJb1FlSfWMU,8765
+fastllm/types.py,sha256=dWFeU3UGA1Z6y5Sn4lmFZfhJe2ROw7skOtg_1W9wgZE,19618
+python_fastllm-0.0.60.dist-info/METADATA,sha256=IL1bXk4TbnCuK8kw9D7DhmIJsiDZa8gLlUFkou29iAU,9136
+python_fastllm-0.0.60.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_fastllm-0.0.60.dist-info/entry_points.txt,sha256=WkWd04F3xVYFP5bsexaQe9Se6uelwE5ULoTtHWreO0s,133
+python_fastllm-0.0.60.dist-info/top_level.txt,sha256=F8qodL7nEGUHGmzzqfhNKCTIr1i0D6cvudOnm3z7o0Y,8
+python_fastllm-0.0.60.dist-info/RECORD,,

python_fastllm-0.0.58.dist-info/METADATA

@@ -1,373 +0,0 @@
-Metadata-Version: 2.4
-Name: python-fastllm
-Version: 0.0.58
-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.27
-Requires-Dist: fasttransport>=0.0.2
-Requires-Dist: pillow
-
-# fastllm
-
-
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
-
-## Install
-
-Run `pip install python-fastllm` or clone from github and install locally.
-
-## Setup
-
-``` python
-from aidialog.msg_parts import Msg, Part, Text, Thinking, ToolUse, InputImage, mk_tool_res_msg, Completion
-from fastllm.acomplete import acomplete
-from fastllm.types import sample_img_url, sample_doms
-import asyncio, json
-
-# Helpers
-def user(text): return Msg(role='user', content=[Text(text)])
-
-async def stream(msgs, model, max_think=10, **kw):
-    "Stream a response, printing each item's `formatted` (🧠 per thinking delta). Returns the final Completion."
-    cnt = 0
-    async for o in await acomplete(msgs, model, stream=True, **kw):
-        if not isinstance(o, Part): continue
-        if isinstance(o, Thinking):
-            cnt += 1
-            if cnt > max_think: continue
-        print(o.formatted, end='', flush=True)
-    print()
-    return o
-```
-
-``` python
-mtok = 1024
-```
-
-## Chat — One Interface, Every Provider
-
-The same `acomplete` call works with Claude, GPT, Gemini, and Kimi. Just change the model name:
-
-``` python
-models = [
-    ('claude-sonnet-5', {}),
-    ('gpt-4o-mini', {}),
-    ('models/gemini-3-flash-preview', {}),
-    ('accounts/fireworks/models/kimi-k2p5', dict(vendor_name='fireworks_ai'))
-]
-for name, kw in models:
-    r = await acomplete([user("Say 'hello' in French.")], model=name, max_tokens=mtok, **kw)
-    print(f"{name:>30s} → {r.message.content[0].text.strip()}")
-```
-
-          claude-sonnet-4-20250514 → Bonjour!
-                       gpt-4o-mini → In French, "hello" is said as "bonjour."
-     models/gemini-3-flash-preview → Bonjour.
-    accounts/fireworks/models/kimi-k2p5 → The user is asking me to say "hello" in French. This is a very straightforward request. The common ways to say hello in French are:
-
-    1. "Bonjour" - the standard, formal way to say hello/good day
-    2. "Salut" - informal way to say hi/hello (also used for goodbye)
-    3. "Bonsoir" - good evening
-    4. "Coucou" - very informal, cute way to say hi
-
-    Since the user just asked for "hello" without specifying context, "Bonjour" is the most appropriate and standard answer. I should provide the most common translation and perhaps mention the informal alternative for completeness.
-
-    The response should be simple and direct.
-
-## System Prompts
-
-Pass a system prompt to any provider — `fastllm` maps it to each API’s native mechanism (Anthropic `system`, OpenAI `instructions`, Gemini `system_instruction`):
-
-``` python
-sys = "You are a pirate chef. Always respond in pirate speak and mention food."
-
-print("Claude: ", end='')
-r = await stream([user("What should I do today?")], model='claude-sonnet-5', system=sys, max_tokens=mtok)
-
-print("Gemini: ", end='')
-r = await stream([user("What should I do today?")], model='models/gemini-3-flash-preview', system=sys, max_tokens=mtok)
-```
-
-    Claude: Ahoy there, me hearty! *tips chef's hat with a feathered plume* 
-
-    Ye be askin' what to do on this fine day, eh? Well, shiver me spatulas, I've got some tasty suggestions for ye!
-
-    First, ye should be raidin' yer galley (that be yer kitchen, landlubber!) and whip up some grub fit for a crew! Perhaps some hearty sea biscuits with honey, or a fine fish stew that'll warm yer bones like treasure warms the heart!
-
-    Then, if the weather be fair, take yerself outside and feel that salty breeze on yer face while ye munch on some portable provisions - maybe some dried fruits and nuts, perfect for any seafarin' adventure!
-
-    And if ye be feelin' ambitious, batten down the hatches and try cookin' somethin' new! A spicy jambalaya or some coconut rice that'll transport ye straight to the Caribbean seas!
-
-    Remember, me matey - a pirate's day ain't complete without good food in yer belly and the spirit of adventure in yer heart! Now off with ye, and may yer meals be as bountiful as buried treasure! 
-
-    *waves wooden spoon like a cutlass*
-
-    Arrr, what say ye? Does any of this grub sound temptin' to yer taste buds?
-    Gemini: Ahoy there, ye scurvy bilge-rat! If ye be lookin' for a way to spend yer daylight hours, I’ve got just the plan for a hungry soul like yerself.
-
-    First, ye should sharpen yer cutlass—not for fightin' off the Royal Navy, mind ye, but for slicin' through a thick slab of **salted pork** and some **ripe mangoes**! A dull blade is the mark of a lazy cook, and we'll have none of that on this vessel.
-
-    Once yer steel is keen, head down to the shoreline and see if ye can't scavenge some **clams** or a **fat crustacean** from the tide pools. If ye find a crab the size of a cannonball, we'll toss it in the pot with some stolen spices and a splash of grog to make a **bisque** that’ll make yer toes curl!
-
-    And if the wind be light, ye can spend the afternoon scrubbin' the barnacles off the hull—it builds an appetite for a massive bowl of **hardtack and lobscouse stew**. 
-
-    Now, quit yer lollygaggin' and get to the galley! There be **onions** that won't peel themselves, and I'll be hornswoggled if I let a single clove of **garlic** go to waste! Arrr!
-
-## Tool Calling — Define Once, Use Anywhere
-
-Define tools in a single canonical format. `fastllm` translates to each provider’s native tool schema automatically. Here Claude requests the tool, receives the result, and answers:
-
-``` python
-tools = [{"type": "function", "function": {
-    "name": "get_weather",
-    "description": "Get current weather for a city",
-    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}
-}}]
-
-# Turn 1: Claude requests the tool
-msgs = [user("What's the weather in Paris?")]
-r1 = await stream(msgs, model='claude-sonnet-5', tools=tools, max_tokens=mtok)
-print("Tool calls:", r1.tool_calls)
-```
-
-    I'll check the current weather in Paris for you.
-    - ⏳ `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, then continue the same conversation
-msgs += [r1.message, mk_tool_res_msg(r1.tool_calls, ['22°C, sunny with light clouds']), user("Should I bring a jacket?")]
-print("Claude: ", end='')
-r2 = await stream(msgs, model='claude-sonnet-5', tools=tools, max_tokens=mtok)
-```
-
-    GPT: With the temperature at 22°C and sunny with light clouds, a jacket isn't necessary for most people. However, if you tend to feel cold easily or if you plan to be out in the evening when it might cool down a bit, it could be a good idea to bring a light jacket.
-
-## Tool Choice
-
-Control whether the model must use tools, can’t use tools, or decides on its own:
-
-``` python
-# Force the model to call a tool (even for a greeting)
-r = await stream([user("Hello there!")], model='claude-sonnet-5', tools=tools, tool_choice='required', max_tokens=mtok)
-print("Forced:", r.tool_calls)
-
-# Prevent tool use (model must answer directly)
-print("\nNo tools: ", end='')
-r = await stream([user("What's the weather?")], model='claude-sonnet-5', tools=tools, tool_choice='none', max_tokens=mtok)
-```
-
-    - ⏳ `get_weather(city="<UNKNOWN>")` ⏳
-
-    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?
-
-## Thinking / Extended Reasoning
-
-Enable model reasoning with `reasoning_effort`. The canonical values (`low`, `medium`, `high`) map to each provider’s native budget system. Thinking tokens stream as 🧠:
-
-``` python
-# Claude with thinking
-print("Claude: ", end='')
-r = await stream([user("What is 127 × 849?")], model='claude-sonnet-4-6', reasoning_effort='low', max_tokens=8192)
-for p in r.message.content:
-    if isinstance(p, Thinking): print(f"\n🧠 {p.text[:150]}...")
-
-# Kimi with thinking — same interface
-print("\nKimi: ", end='')
-r = await stream([user("What is 127 × 849?")], model='accounts/fireworks/models/kimi-k2p5', vendor_name='fireworks_ai', reasoning_effort='low', max_tokens=8192)
-for p in r.message.content:
-    if isinstance(p, Thinking): print(f"\n🧠 {p.text[:150]}...")
-```
-
-    Claude: 🧠🧠🧠## Calculating 127 × 849
-
-    **Breaking it down:**
-    - 127 × 800 = 101,600
-    - 127 × 40 = 5,080
-    - 127 × 9 = 1,143
-
-    **Adding the parts:**
-    101,600 + 5,080 + 1,143 = **107,823**
-
-    🧠 127 × 849:
-    127 × 800 = 101,600
-    127 × 49 = 127 × 50 - 127 = 6350 - 127 = 6223
-    Total: 107,823...
-
-    Kimi: 🧠🧠🧠🧠🧠🧠🧠🧠🧠🧠**107,823**
-
-    Here's the calculation:
-    - 127 × 800 = 101,600
-    - 127 × 40 = 5,080  
-    - 127 × 9 = 1,143
-    - **Total: 101,600 + 5,080 + 1,143 = 107,823**
-
-    🧠 The user is asking for the product of 127 and 849. I need to calculate 127 × 849.
-
-    Let me calculate this step by step.
-
-    Method 1: Standard multiplicat...
-
-## Web Search (Server Tools)
-
-OpenAI’s Responses API supports server-side web search. Server tool calls are normalized alongside regular tool calls:
-
-``` python
-ws_tools = [{"type": "web_search_preview"}]
-print("GPT + web search: ", end='')
-r = await stream([user("What is the latest Python release?")], model='gpt-4o-mini', tools=ws_tools, max_tokens=512)
-print(f"\nServer tools used: {[tc.name for tc in r.tool_calls if tc.server]}")
-```
-
-    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:
-
-    - **PEP 779**: Official support for free-threaded Python, allowing threads to run more concurrently.
-    - **PEP 649**: Deferred evaluation of annotations, improving the semantics of using annotations.
-    - **PEP 750**: Template string literals (t-strings) for custom string processing, using the familiar syntax of f-strings.
-    - **PEP 734**: Support for multiple interpreters in the standard library.
-    - **PEP 784**: A new module `compression.zstd` providing support for the Zstandard compression algorithm.
-
-    For a comprehensive list of changes and improvements in Python 3.14, you can refer to the official release notes. ([docs.python.org](https://docs.python.org/it/3.14/whatsnew/3.14.html?utm_source=openai))
-
-    You can download the latest version of Python from the official Python website. ([python.org](https://www.python.org/downloads/?lang=python&utm_source=openai)) 
-
-    Server tools used: ['web_search']
-
-## Caching (Anthropic)
-
-Anthropic supports prompt caching via `cache_control`. Set it on a part’s `cache_control` — repeat calls with the same cached content save tokens:
-
-``` python
-# Cache a long system prompt (must be >1024 tokens for Anthropic caching)
-long_ctx = "You are an expert on the solar system. " * 200
-system = Text(long_ctx, cache_control={'type': 'ephemeral'})
-
-print("Call 1: ", end='')
-r1 = await stream([user("What is Jupiter's mass?")], model='claude-sonnet-5', system=system, max_tokens=mtok)
-print(f"Usage: {r1.usage}")
-
-print("Call 2: ", end='')
-r2 = await stream([user("How about Saturn?")], model='claude-sonnet-5', system=system, max_tokens=mtok)
-print(f"Usage: {r2.usage}")
-```
-
-    Call 1: Jupiter's mass is approximately 1.898 × 10²⁷ kilograms (or 1,898,000,000,000,000,000,000,000,000 kg).
-
-    To put this in perspective:
-    - Jupiter is about 318 times more massive than Earth
-    - It contains more than twice the mass of all other planets in our solar system combined
-    - Jupiter's mass is about 1/1047th the mass of the Sun
-
-    This enormous mass gives Jupiter its strong gravitational influence, which helps it act as a "cosmic vacuum cleaner" by capturing asteroids and comets that might otherwise threaten the inner planets.
-    Usage: Usage(prompt_tokens=1814, completion_tokens=145, total_tokens=1959, cached_tokens=0, cache_creation_tokens=1802, reasoning_tokens=0, raw={'input_tokens': 12, 'cache_creation_input_tokens': 1802, 'cache_read_input_tokens': 0, 'output_tokens': 145})
-    Call 2: Saturn is truly one of the most spectacular planets in our solar system! Here are some key facts about this gas giant:
-
-    **Basic Characteristics:**
-    - Sixth planet from the Sun
-    - Second largest planet (after Jupiter)
-    - Composed primarily of hydrogen and helium
-    - Has the lowest density of any planet - it would actually float in water!
-
-    **Famous Ring System:**
-    - Most prominent and extensive ring system in the solar system
-    - Made primarily of ice particles and rocky debris
-    - Rings are organized into distinct sections (A, B, C rings are the main ones)
-    - Ring particles range from tiny ice crystals to house-sized chunks
-
-    **Moons:**
-    - Has 146 confirmed moons (the most of any planet)
-    - Titan is its largest moon - larger than Mercury and has a thick atmosphere
-    - Enceladus has geysers of water ice erupting from its south pole
-    - Many other fascinating moons like Iapetus, Mimas, and Dione
-
-    **Physical Features:**
-    - Takes about 29.5 Earth years to orbit the Sun
-    - A day on Saturn is only about 10.7 hours
-    - Has extreme winds reaching up to 1,800 km/h
-    - Beautiful hexagonal storm at its north pole
-
-    **Exploration:**
-    - Visited by Pioneer 11, Voyager 1 & 2, and most notably the Cassini mission (2004-2017)
-
-    Is there a particular aspect of Saturn you'd like to know more about?
-    Usage: Usage(prompt_tokens=1812, completion_tokens=337, total_tokens=2149, cached_tokens=1802, cache_creation_tokens=0, reasoning_tokens=0, raw={'input_tokens': 10, 'cache_creation_input_tokens': 0, 'cache_read_input_tokens': 1802, 'output_tokens': 337})
-
-## Media Inputs
-
-Send images to any provider that supports them. The canonical `input_image` part works everywhere:
-
-``` python
-img_msg = Msg(role='user', content=[
-    InputImage(sample_img_url),
-    Text("What do you see in this image?")
-])
-
-for name, kw in [('claude-sonnet-5', {}), ('gpt-4o-mini', {}), ('models/gemini-3-flash-preview', {})]:
-    print(f"{name:>30s}: ", end='')
-    r = await stream([img_msg], model=name, max_tokens=mtok, **kw)
-```
-
-          claude-sonnet-4-20250514: I see a beautiful, serene landscape photograph taken from what appears to be a wooden dock or platform. The image shows:
-
-    - A perfectly still lake that creates mirror-like reflections
-    - Snow-capped mountains in the background under a partly cloudy sky
-    - Dense forests of evergreen trees (likely pine or fir) lining the shoreline
-    - The mountains, trees, and sky all reflected clearly in the calm water
-    - Wooden planks in the foreground, suggesting the photo was taken from a dock or wooden viewing platform
-    - The lighting appears soft and atmospheric, possibly during golden hour
-    - The overall scene has a very peaceful, pristine wilderness quality typical of places like the Canadian Rockies, Alaska, or similar mountainous lake regions
-
-    The composition creates a sense of depth and tranquility, with the wooden platform in the foreground leading the eye toward the expansive natural landscape beyond.
-                       gpt-4o-mini: The image features a serene landscape with a body of water reflecting surrounding trees and mountains. In the foreground, there is a wooden deck or platform, enhancing the picturesque view. The scene is calm and depicts natural beauty, characterized by lush greenery, a clear sky, and distant snow-capped mountains.
-     models/gemini-3-flash-preview: This image depicts a serene and majestic landscape, viewed from the perspective of someone standing on a wooden deck.
-
-    Here is a breakdown of what is visible:
-
-    *   **Foreground:** In the immediate foreground are weathered brown wooden planks of a deck or pier. The planks run diagonally, drawing the eye toward the center of the image.
-    *   **Midground (The Lake):** Beyond the deck is a large, still lake. The water is a deep blue and acts as a perfect mirror, reflecting the trees and mountains above with startling clarity.
-    *   **Shoreline:** Along the far edge of the lake is a dense line of lush green evergreen trees. A thin, bright yellow or golden strip of vegetation runs along the very edge of the water.
-    *   **Background (Mountains):** Towering over the entire scene are massive, rugged mountains. The peaks are covered in white snow or glaciers and appear in shades of light blue and grey due to a soft, atmospheric haze.
-    *   **Sky:** The sky is a pale, bright blue, almost white in some areas, with a few soft clouds visible in the upper right corner.
-
-    The overall mood of the image is peaceful, cool-toned, and tranquil.
-
-`fastllm` supports four media part classes. Provider support varies:
-
-| Media part   | Anthropic | OpenAI Responses | OpenAI Chat | Gemini |
-|--------------|-----------|------------------|-------------|--------|
-| `InputImage` | ✅        | ✅               | ✅          | ✅     |
-| `InputAudio` | ❌        | ❌ (coming soon) | ✅          | ✅     |
-| `InputVideo` | ❌        | ❌               | ❌          | ✅     |
-| `InputFile`  | ✅        | ✅               | ✅          | ✅     |
-
-All media parts accept either a URL or a base64 data URL as their `text`. Unsupported combinations raise a clear `ValueError`.

python_fastllm-0.0.58.dist-info/RECORD

@@ -1,18 +0,0 @@
-fastllm/__init__.py,sha256=uDoIIuBjxZKcbyRrdFaaGJlfJwWkr9dF7dNA3b04A9k,131
-fastllm/_modidx.py,sha256=qzUtLbjOche-GNbeNun3VRIQdcm5g4dUOCLJ6T9fG-w,46374
-fastllm/acomplete.py,sha256=CusLue35xiaswpmTZyLkJj6t4CVsNDeeY3Sk7hzVNoY,10777
-fastllm/anthropic.py,sha256=ktH-EuQMQnp8O2_6VmSrvvDCIe2QTeSR7jNpWfqf3L4,18884
-fastllm/chat.py,sha256=klji3SOYs5xyzrSFbNhy3uoQ2TSZ3a-8HTjvdRtaG5Q,25036
-fastllm/codex.py,sha256=r6auZ8egia83aGkWcF4132AzW4SsBvKeDwg_CxyXj9E,5808
-fastllm/gemini.py,sha256=vpY_f4Jqn344l9CANm6_c7Cmhjq2URXxWhdVv_LswSg,17615
-fastllm/model_prices.json,sha256=pa0j96LZgklYii8howX443QbukUP1iFr3lBcucS-6Yo,2133018
-fastllm/openai_chat.py,sha256=n5INfDCsAZIiKUImWeaX6SJ_OAJ_uMhw20HUkgFgdgM,12379
-fastllm/openai_responses.py,sha256=NrvzNCKkSQabbAMnxYCSPdROaT1u8Vp2eoRzbzAA-4M,15345
-fastllm/responses.py,sha256=9gh-UlhfswCcP0RCzLuPT5meWNh9mF_OIivzCzZU94I,22726
-fastllm/streaming.py,sha256=DrqNJkMhyntFKokY6GF6oW3CjELrk5XWmnxwcApJUyM,8770
-fastllm/types.py,sha256=OznlKQZUx2DrLE_O-sbIBsT6q6EBeVDlH9kXxhsGBSE,19445
-python_fastllm-0.0.58.dist-info/METADATA,sha256=scQa4XA1Oh28m6HO6knQtPmOwV_E0ppqFdXuMH8GTA8,18537
-python_fastllm-0.0.58.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_fastllm-0.0.58.dist-info/entry_points.txt,sha256=WkWd04F3xVYFP5bsexaQe9Se6uelwE5ULoTtHWreO0s,133
-python_fastllm-0.0.58.dist-info/top_level.txt,sha256=F8qodL7nEGUHGmzzqfhNKCTIr1i0D6cvudOnm3z7o0Y,8
-python_fastllm-0.0.58.dist-info/RECORD,,