python-fastllm 0.0.45__py3-none-any.whl → 0.0.47__py3-none-any.whl

fastllm/__init__.py

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

fastllm/_modidx.py

@@ -237,6 +237,10 @@ d = { 'settings': { 'branch': 'main',
                                                                                 'fastllm/responses.py'),
                                    'fastllm.responses.AsyncResponses.prepare': ( 'responses.html#asyncresponses.prepare',
                                                                                  'fastllm/responses.py'),
+                                   'fastllm.responses.AsyncResponses.server_results': ( 'responses.html#asyncresponses.server_results',
+                                                                                        'fastllm/responses.py'),
+                                   'fastllm.responses.AsyncResponses.server_turn': ( 'responses.html#asyncresponses.server_turn',
+                                                                                     'fastllm/responses.py'),
                                    'fastllm.responses.AsyncResponses.state': ( 'responses.html#asyncresponses.state',
                                                                                'fastllm/responses.py'),
                                    'fastllm.responses.ResponseState': ('responses.html#responsestate', 'fastllm/responses.py'),
@@ -316,10 +320,13 @@ d = { 'settings': { 'branch': 'main',
                                'fastllm.types.Completion.cost': ('types.html#completion.cost', 'fastllm/types.py'),
                                'fastllm.types.Completion.formatted': ('types.html#completion.formatted', 'fastllm/types.py'),
                                'fastllm.types.Usage': ('types.html#usage', 'fastllm/types.py'),
+                               'fastllm.types.Usage.__add__': ('types.html#usage.__add__', 'fastllm/types.py'),
                                'fastllm.types.Usage.__eq__': ('types.html#usage.__eq__', 'fastllm/types.py'),
                                'fastllm.types.Usage.__init__': ('types.html#usage.__init__', 'fastllm/types.py'),
                                'fastllm.types._rm_ctx_tiers': ('types.html#_rm_ctx_tiers', 'fastllm/types.py'),
                                'fastllm.types.approx_pricing': ('types.html#approx_pricing', 'fastllm/types.py'),
+                               'fastllm.types.effort_code': ('types.html#effort_code', 'fastllm/types.py'),
+                               'fastllm.types.effort_levels': ('types.html#effort_levels', 'fastllm/types.py'),
                                'fastllm.types.fn_schema': ('types.html#fn_schema', 'fastllm/types.py'),
                                'fastllm.types.get_api_key': ('types.html#get_api_key', 'fastllm/types.py'),
                                'fastllm.types.get_model_info': ('types.html#get_model_info', 'fastllm/types.py'),
@@ -334,6 +341,7 @@ d = { 'settings': { 'branch': 'main',
                                '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.resolve_effort': ('types.html#resolve_effort', 'fastllm/types.py'),
                                'fastllm.types.tier_rate': ('types.html#tier_rate', 'fastllm/types.py'),
                                'fastllm.types.unwrap_typed': ('types.html#unwrap_typed', 'fastllm/types.py'),
                                'fastllm.types.wrap_typed': ('types.html#wrap_typed', 'fastllm/types.py')}}}

fastllm/chat.py

@@ -225,21 +225,15 @@ 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)
-        eff = dict(thinking={"type":"adaptive", "display":"summarized"}, output_config={"effort":e})
-        return dict(reasoning_effort=eff)
-    try: xhigh = get_model_info(model, vendor_name).get('supports_xhigh_reasoning_effort')
-    except: xhigh = False
-    eff = effort.get(think) if think!='x' else 'xhigh' if xhigh else 'high'
+    if think is None or think == '': return {}
+    eff = resolve_effort(effort_levels(get_model_info(model, vendor_name)), think)
+    if eff is None: return {}
+    if 'opus-4-7' in model: return dict(reasoning_effort=dict(thinking={"type":"adaptive", "display":"summarized"}, output_config={"effort":eff}))
     if vendor_name == 'codex': return dict(reasoning_effort={'effort':eff, 'summary':'auto'})
     return dict(reasoning_effort=eff)
 
+
 # %% ../nbs/07_chat.ipynb #06e898fd
 @patch
 def _prep_call(self:AsyncChat, search, max_tokens, kwargs, stream=False, think=None):
@@ -256,7 +250,7 @@ def _prep_call(self:AsyncChat, search, max_tokens, kwargs, stream=False, think=N
     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
+    if self.extra_headers: kwargs['xtra_hdrs'] = self.extra_headers
     kwargs.update(_think_kw(self.model, think, self.vendor_name))
     return max_tokens
 

fastllm/openai_responses.py

@@ -186,6 +186,7 @@ def denorm_tool_choice(v):
 def denorm_reasoning(v):
     "Map canonical reasoning_effort to OpenAI Responses reasoning param."
     if v is None: return None
+    if isinstance(v, int): return {'level': v}  # a 0-3 level, for a Responses server that resolves it per model
     return {'effort': v} if isinstance(v, str) else v
 
 # %% ../nbs/02_oai_responses.ipynb #e11c15c0

fastllm/responses.py

@@ -15,13 +15,14 @@ __all__ = ['ResponsesError', 'response_input', 'normalize_call_ids', 'response_o
            'ResponseState', 'ResponseTurn', 'AsyncResponses', 'response_event', 'pending_response']
 
 # %% ../nbs/06a_responses.ipynb #e16fc24e
-import asyncio, json, secrets, time
+import asyncio, copy, json, secrets, time
 from fastcore.utils import *
+from fastcore.funccall import call_func_async, get_schema
 from fasttransport.errors import APIError
 
 from .acomplete import acomplete
 from .streaming import Status
-from aidialog.msg_parts import Msg, Text, ToolUse, ToolResult, InputImage, InputFile, Completion
+from aidialog.msg_parts import Msg, Text, ToolUse, ToolResult, InputImage, InputFile, Completion, tool_text
 
 # %% ../nbs/06a_responses.ipynb #f904c16f
 class ResponsesError(Exception):
@@ -69,7 +70,9 @@ def response_input(inp):
             if isinstance(args, str):
                 try: args = json.loads(args)
                 except json.JSONDecodeError: pass
-            msgs.append(Msg('assistant', [ToolUse(id=item.get('call_id'), name=item.get('name'), arguments=args)]))
+            call = ToolUse(id=item.get('call_id'), name=item.get('name'), arguments=args)
+            if msgs and msgs[-1].role == 'assistant': msgs[-1].content.append(call)
+            else: msgs.append(Msg('assistant', [call]))
         elif typ == 'function_call_output':
             out = item.get('output', '')
             pending_tools.append(ToolResult(id=item.get('call_id'), name=item.get('name', ''),
@@ -145,15 +148,18 @@ class ResponseState(BasicRepr):
 # %% ../nbs/06a_responses.ipynb #c9ca3744
 class ResponseTurn(BasicRepr):
     "A prepared Responses request for one provider call."
-    def __init__(self, id, created_at, body, history, provider_messages, system='', previous=None): store_attr()
+    def __init__(self, id, created_at, body, history, provider_messages, system='', previous=None, server_tools=None):
+        store_attr()
+        if server_tools is None: self.server_tools = {}
 
     @property
     def provider_previous_id(self): return self.previous.provider_response_id if self.previous else None
 
+
 # %% ../nbs/06a_responses.ipynb #a648297f
 class AsyncResponses:
     "Run individual Responses turns over FastLLM."
-    def prepare(self, body, previous=None):
+    def prepare(self, body, previous=None, server_tools=None):
         if not isinstance(body, dict): raise ResponsesError('Request body must be an object')
         model = body.get('model')
         if not model: raise ResponsesError('model is required', param='model')
@@ -167,27 +173,57 @@ class AsyncResponses:
                 if isinstance(p, ToolResult) and not p.name: p.name = names.get(p.id, '')
         instructions = '\n\n'.join(filter(None, [body.get('instructions', ''), input_system]))
         provider_messages = new_msgs if previous and previous.provider_response_id else list(history)
-        return ResponseTurn(_new_id('resp'), int(time.time()), body, history, provider_messages, instructions, previous)
+        return ResponseTurn(_new_id('resp'), int(time.time()), body, history, provider_messages, instructions, previous,
+            {f.__name__: f for f in server_tools or []})
+
 
 # %% ../nbs/06a_responses.ipynb #373f7d5e
 @patch
 async def call(self:AsyncResponses, turn):
-    "Start the provider stream for a prepared turn."
+    "Start the provider stream for a prepared turn, having received its first chunk"
     body = turn.body
     reasoning = body.get('reasoning') or {}
-    kwargs = dict(previous_response_id=turn.provider_previous_id, system=turn.system or None, tools=body.get('tools'))
+    tools = list(body.get('tools') or []) + [dict(type='function', **get_schema(f, pname='parameters')) for f in turn.server_tools.values()]
+    kwargs = dict(previous_response_id=turn.provider_previous_id, system=turn.system or None, tools=tools or None)
     kwargs.update(tool_choice=body.get('tool_choice'), parallel_tool_calls=body.get('parallel_tool_calls', True),
         reasoning_effort=reasoning.get('effort'), max_tokens=body.get('max_output_tokens'), temperature=body.get('temperature'),
         cache_idxs=body.get('cache_idxs'), ttl=body.get('ttl'), web_search_options=body.get('web_search_options'))
-    return await acomplete(turn.provider_messages, model=body['model'], stream=True, **kwargs)
+    stream = await acomplete(turn.provider_messages, model=body['model'], stream=True, **kwargs)
+    first = await anext(stream)
+    async def _rest():
+        yield first
+        async for o in stream: yield o
+    return _rest()
+
 
 # %% ../nbs/06a_responses.ipynb #4f424285
 @patch
-def state(self:AsyncResponses, turn, comp):
-    "Build the next continuation state."
+def state(self:AsyncResponses, turn, comp, results=()):
+    "Build the next continuation state; `results` are server tool results answering `comp`'s calls."
     normalize_call_ids(comp)
-    return ResponseState(turn.id, turn.body['model'], (*turn.history, comp.message),
-        comp.response_id, comp.response_id_reusable)
+    history = (*turn.history, comp.message, *([Msg('tool', list(results))] if results else []))
+    return ResponseState(turn.id, turn.body['model'], history, comp.response_id, comp.response_id_reusable)
+
+
+# %% ../nbs/06a_responses.ipynb #7615b274
+@patch
+async def server_results(self:AsyncResponses, turn, comp):
+    "Run the server tool calls in `comp`, returning their results"
+    normalize_call_ids(comp)
+    res = []
+    for tc in comp.tool_calls:
+        if tc.name not in turn.server_tools: continue
+        out = await call_func_async(tc.name, tc.arguments, ns=turn.server_tools, raise_on_err=False)
+        res.append(ToolResult(id=tc.id, name=tc.name, arguments=tc.arguments, text=tool_text(out)))
+    return res
+
+@patch
+def server_turn(self:AsyncResponses, turn, comp, results):
+    "The follow-up provider turn answering server tool `results`, within the same public response"
+    outputs = [dict(type='function_call_output', call_id=r.id, output=r.text) for r in results]
+    nxt = self.prepare(turn.body | dict(input=outputs), self.state(turn, comp), turn.server_tools.values())
+    nxt.id = turn.id
+    return nxt
 
 # %% ../nbs/06a_responses.ipynb #25502099
 def response_event(event_type, sequence_number, **kwargs):
@@ -278,22 +314,31 @@ def done_events(self:_ResponseStream, comp):
 
 # %% ../nbs/06a_responses.ipynb #e10c928b
 @patch
-async def events(self:AsyncResponses, turn, finalize=None):
-    state = _ResponseStream(turn)
+async def events(self:AsyncResponses, turn, finalize=None, stream=None):
+    state,first = _ResponseStream(turn),turn
     yield state.event('response.created', response=pending_response(turn))
     try:
-        stream = await self.call(turn)
-        async for part in stream:
-            if isinstance(part, Status): continue
-            if isinstance(part, Completion): comp = part
-            else:
-                for event in state.part_events(part): yield event
+        texts,usage = [],None
+        while True:
+            async for part in (stream or await self.call(turn)):
+                if isinstance(part, Completion): comp = part
+                elif isinstance(part, Status) or (isinstance(part, ToolUse) and part.name in turn.server_tools): continue
+                else:
+                    for event in state.part_events(part): yield event
+            usage,stream = (comp.usage if usage is None else usage + comp.usage),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)]
+            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
         for event in state.done_events(comp): yield event
-        next_state = self.state(turn, comp)
-        response = response_object(turn.id, turn.body, comp, turn.previous.id if turn.previous else None, turn.created_at)
+        response = response_object(first.id, first.body, comp, first.previous.id if first.previous else None, first.created_at)
         if finalize: await finalize(next_state, comp)
         name = 'response.incomplete' if response['status'] == 'incomplete' else 'response.completed'
         yield state.event(name, response=response)
     except asyncio.CancelledError: raise
     except ResponsesError as exc: yield state.event('error', code=exc.code, message=str(exc), param=exc.param)
     except APIError as exc: yield state.event('error', code=exc.code or 'provider_error', message=str(exc), param=None)
+

fastllm/types.py

@@ -3,12 +3,13 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/00_types.ipynb.
 
 # %% auto #0
-__all__ = ['FinishReason', 'api_registry', 'model_prices_url', 'haik45', 'sonn45', 'sonn46', 'sonn', 'sonn5', 'opus46', 'opus48',
-           'opus', 'opus5', 'fable', 'fable5', 'gpt54', 'gpt54m', 'gpt55', 'codex54', 'codex54m', 'codex55',
-           'codex53spark', 'model_info_registry', 'modern_llm', 'deepseek_v4_common', 'mimo_v25_common',
-           'codex_pricing', 'sol', 'terra', 'luna', 'gpt56s', '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',
+__all__ = ['FinishReason', 'api_registry', 'model_prices_url', 'sample_img_url', 'haik45', 'sonn45', 'sonn46', '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', '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']
 
 # %% ../nbs/00_types.ipynb #b4d047fd
@@ -32,6 +33,12 @@ class Usage(BasicRepr):
     def __eq__(self, o): return type(o) is type(self) and self.__dict__ == o.__dict__
 
 
+# %% ../nbs/00_types.ipynb #bae1c130
+@patch
+def __add__(self:Usage, o):
+    fields = 'prompt_tokens completion_tokens total_tokens cached_tokens cache_creation_tokens reasoning_tokens'.split()
+    return Usage(**{k: getattr(self, k)+getattr(o, k) for k in fields}, raw=o.raw)
+
 # %% ../nbs/00_types.ipynb #4901e693
 @patch(as_prop=True)
 def formatted(self:Completion): return ''
@@ -160,6 +167,9 @@ def model_prices_meta():
     if not p.exists(): p.write_text(httpx2.get(model_prices_url, follow_redirects=True).text)
     return loads(p.read_text())
 
+# %% ../nbs/00_types.ipynb #019882a3
+sample_img_url = "https://img.magnific.com/free-photo/mountain-range-body-water_53876-139760.jpg?semt=ais_hybrid&w=740&q=80"
+
 # %% ../nbs/00_types.ipynb #68e488d8
 def infer_api_name(model):
     "Infer api_name from model"
@@ -186,6 +196,7 @@ opus46 = "claude-opus-4-6"
 opus48 = "claude-opus-4-8"
 opus = opus5 = "claude-opus-5"
 fable = fable5 = 'claude-fable-5'
+fable51 = 'claude-fable-5-1'
 gpt54 = "gpt-5.4"
 gpt54m = "gpt-5.4-mini"
 gpt55 = "gpt-5.5"
@@ -216,56 +227,55 @@ modern_llm = dict(supports_function_calling=True, supports_tool_choice=True, sup
     supports_reasoning=True, supports_response_schema=True, supports_system_messages=True)
 
 # %% ../nbs/00_types.ipynb #8261dcd0
-register_model_info('accounts/fireworks/models/qwen3p7-plus', vendor_name='fireworks_ai', **modern_llm, supports_vision=True,
-    max_tokens=1000000, max_input_tokens=1000000, max_output_tokens=65536,
-    input_cost_per_token=0.4e-6, cache_read_input_token_cost=0.08e-6, output_cost_per_token=1.6e-6)
-
-register_model_info('accounts/fireworks/models/qwen3p6-plus', vendor_name='fireworks_ai', **modern_llm, supports_vision=True,
-    max_tokens=1000000, max_input_tokens=1000000, max_output_tokens=65536,
-    input_cost_per_token=0.5e-6, cache_read_input_token_cost=0.1e-6, output_cost_per_token=3.0e-6)
-
-register_model_info('accounts/fireworks/models/glm-5p2', vendor_name='fireworks_ai', **modern_llm, supports_vision=False,
-    max_tokens=1000000, max_input_tokens=1000000, max_output_tokens=65536,
-    input_cost_per_token=1.4e-6, cache_read_input_token_cost=0.14e-6, output_cost_per_token=4.4e-6)
-
-register_model_info('accounts/fireworks/routers/glm-5p2-fast', vendor_name='fireworks_ai', **modern_llm, supports_vision=False,
-    max_tokens=1000000, max_input_tokens=1000000, max_output_tokens=65536,
-    input_cost_per_token=2.8e-6, cache_read_input_token_cost=0.28e-6, output_cost_per_token=8.8e-6)
-
-register_model_info('gemini-3.5-flash', vendor_name='gemini', base='gemini-3-flash-preview',
-    input_cost_per_token=1.5e-6, output_cost_per_token=9e-6, output_cost_per_reasoning_token=9e-6, cache_read_input_token_cost=1.5e-7)
-
-register_model_info('gpt-5.4', vendor_name='openai', base='gpt-5.4', supports_web_search=True, mode=None)
-# Upstream metadata says 1,050,000 input tokens for gpt-5.4-mini, but OpenAI documents a 272k limit
-register_model_info('gpt-5.4-mini', vendor_name='openai', base='gpt-5.4-mini', supports_web_search=True, mode=None, max_input_tokens=272_000)
-
-for model in ('kimi-k2.5', 'kimi-k2.6' , 'kimi-k3'):
-    register_model_info(model, vendor_name='moonshot', base=f'moonshot/{model}', base_vendor_name=None,
-        supports_reasoning=True, supports_vision=True)
-
-register_model_info('gemini-3.1-flash-lite', vendor_name='gemini', base='gemini-3.1-flash-lite-preview')
-register_model_info('models/gemini-3.1-flash-lite', vendor_name='gemini', base='gemini-3.1-flash-lite-preview')
-
-register_model_info('accounts/fireworks/models/kimi-k2p5', vendor_name='fireworks_ai', base='accounts/fireworks/models/kimi-k2p5',
-    supports_reasoning=True, supports_vision=True,
-    input_cost_per_token=0.60e-6, cache_read_input_token_cost=0.10e-6, output_cost_per_token=3.0e-6)
-register_model_info('accounts/fireworks/models/kimi-k2p6', vendor_name='fireworks_ai', base='accounts/fireworks/models/kimi-k2p5',
-    supports_reasoning=True, supports_vision=True,
-    input_cost_per_token=0.95e-6, cache_read_input_token_cost=0.16e-6, output_cost_per_token=4.0e-6)
-register_model_info('kimi-k2.7-code', vendor_name='moonshot', base='kimi-k2.6',
-    input_cost_per_token=0.95e-6, cache_read_input_token_cost=0.19e-6, output_cost_per_token=4.0e-6)
-register_model_info('kimi-k3', vendor_name='moonshot', base='kimi-k2.6', supports_reasoning=True, supports_vision=True,
-    max_input_tokens=1_000_000, input_cost_per_token=3e-6, cache_read_input_token_cost=0.30e-6, output_cost_per_token=15.0e-6)
+register_model_info('gpt-5.4', vendor_name='openai', base='gpt-5.4', supports_web_search=True)
+
+register_model_info('accounts/fireworks/models/deepseek-v4-flash-vision-exp', vendor_name='fireworks_ai',
+    base='accounts/fireworks/models/deepseek-v4-flash-0731', supports_vision=True)
+register_model_info('glm-5.3-flash', vendor_name='zai', base='glm-5.3-flash', reasoning_effort_levels=['low', 'high', 'max'])
+register_model_info('accounts/fireworks/models/glm-5p3-flash', vendor_name='fireworks_ai', base='glm-5.3-flash', base_vendor_name='zai')
+
+# %% ../nbs/00_types.ipynb #b6279e07
+effort_codes = dict(n='none', l='low', m='medium', h='high', x='xhigh')
+
+def effort_code(v):
+    "The effort code (`n l m h x`) for an effort name, code, or level 0-3"
+    if isinstance(v, int): return 'lmhx'[v]
+    return {**{v:k for k,v in effort_codes.items()}, 'max':'x'}.get(v, v)
+
+def effort_levels(info):
+    "Ordered reasoning effort levels a model accepts, lowest first, from its metadata `info`; empty when it does not reason"
+    if not info.get('supports_reasoning'): return []
+    if lv := info.get('reasoning_effort_levels'): return list(lv)
+    lv = ['low', 'medium', 'high']
+    if info.get('supports_none_reasoning_effort'): lv.insert(0, 'none')
+    if info.get('supports_xhigh_reasoning_effort'): lv.append('xhigh')
+    if info.get('supports_max_reasoning_effort'): lv.append('max')
+    return lv
+
+def resolve_effort(levels, effort):
+    "The level among ordered `levels` that `effort` (a code `n l m h x`, a name, or a level 0-3) selects; None when `n` has no `none` level"
+    code = effort_code(effort)
+    lv = [o for o in levels if o != 'none']
+    if code not in effort_codes: return effort
+    if not lv: return effort if isinstance(effort, int) else effort_codes[code]
+    if code == 'n': return 'none' if 'none' in levels else None
+    if code == 'x': return lv[-1]
+    return lv[min('lmh'.index(code), len(lv)-1)]
 
-# %% ../nbs/00_types.ipynb #948d55d0
-deepseek_v4_common = dict(**modern_llm, max_input_tokens=1048576, max_output_tokens=393216, max_tokens=393216)
 
-register_model_info('deepseek-v4-flash', vendor_name='deepseek', base='deepseek/deepseek-v3.2', **deepseek_v4_common,
-    input_cost_per_token=1.4e-07, input_cost_per_token_cache_hit=2.8e-09,
-    output_cost_per_token=2.8e-07, cache_read_input_token_cost=1.4e-07/10)
-register_model_info('deepseek-v4-pro', vendor_name='deepseek', base='deepseek/deepseek-v3.2', **deepseek_v4_common,
-    input_cost_per_token=4.35e-07, input_cost_per_token_cache_hit=3.625e-09,
-    output_cost_per_token=8.7e-07, cache_read_input_token_cost=4.35e-07/10)
+# %% ../nbs/00_types.ipynb #948d55d0
+# The price map carries DeepSeek's peak rates, and `Completion.cost` doubles at peak, so register the off-peak rates
+deepseek_v4_common = dict(supports_native_structured_output=True)
+deepseek_v4_flash_prices = dict(input_cost_per_token=0.22e-6, input_cost_per_token_cache_hit=0.007e-6,
+    cache_read_input_token_cost=0.007e-6, output_cost_per_token=0.66e-6)
+
+register_model_info('deepseek-v4-flash', vendor_name='deepseek', base='deepseek-v4-flash',
+    **deepseek_v4_common, **deepseek_v4_flash_prices)
+register_model_info('deepseek-v4-flash-vision-exp', vendor_name='deepseek', base='deepseek-v4-flash-vision-exp',
+    **deepseek_v4_common, **deepseek_v4_flash_prices, supports_image_input=True)
+register_model_info('deepseek-v4-pro', vendor_name='deepseek', base='deepseek-v4-pro', **deepseek_v4_common,
+    input_cost_per_token=0.66e-6, input_cost_per_token_cache_hit=0.022e-6,
+    cache_read_input_token_cost=0.022e-6, output_cost_per_token=1.98e-6)
 
 mimo_v25_common = dict(**modern_llm, supports_web_search=True, max_input_tokens=1048576, max_output_tokens=131072, max_tokens=131072)
 
@@ -286,12 +296,6 @@ register_model_info('muse-spark-1.1', vendor_name='meta_ai', **modern_llm, max_i
     supports_vision=True, supports_image_input=True, supports_video_input=True, supports_pdf_input=True, supports_web_search=True,
     search_context_cost_per_query=0.0025, input_cost_per_token=1.25e-6, output_cost_per_token=4.25e-6, cache_read_input_token_cost=0.15e-6)
 
-# %% ../nbs/00_types.ipynb #5a2b3430
-# z.ai list pricing (a 50% discount applies until 2026-09-09)
-register_model_info('glm-5.3-flash', vendor_name='zai', base='glm-5.1', **modern_llm, supports_vision=True, supports_image_input=True,
-    max_input_tokens=1000000, max_output_tokens=128000, max_tokens=128000, input_cost_per_token=1.5e-07, cache_read_input_token_cost=3e-08,
-    output_cost_per_token=5e-07)
-
 # %% ../nbs/00_types.ipynb #2c23d11e
 codex_pricing = dict(input_cost_per_token = 0.10/1_000_000, output_cost_per_token = 0.50/1_000_000,
     cache_creation_input_token_cost = 0.10/1_000_000, cache_read_input_token_cost = 0.10/1_000_000)
@@ -310,12 +314,13 @@ register_model_info(codex53spark, 'codex', **codex_pricing,
     max_tokens=128000, max_input_tokens=128000, max_output_tokens=128000)
 
 # %% ../nbs/00_types.ipynb #5d3e4720
-for model in (haik45, sonn45, sonn46, sonn5, opus46, opus48, opus5, fable5):
+# Fable 5.1 isn't in the price map yet; it prices and behaves like Fable 5
+register_model_info(fable51, 'anthropic', base=fable5)
+for model in (haik45, sonn45, sonn46, sonn5, opus46, opus48, opus5, fable5, fable51):
     register_model_info(model, 'claude_code', base=model, base_vendor_name='anthropic', **codex_pricing)
 
 # %% ../nbs/00_types.ipynb #bb0c4c2a
 sol,terra,luna = gpt56s = 'gpt-5.6-sol gpt-5.6-terra gpt-5.6-luna'.split()
-for model in ['gpt-5.6']+gpt56s: register_model_info(model, 'openai', base=model, base_vendor_name='openai')
 # 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.
 for model in gpt56s:

{python_fastllm-0.0.45.dist-info → python_fastllm-0.0.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fastllm
-Version: 0.0.45
+Version: 0.0.47
 Author-email: Kerem Turgutlu <keremturgutlu@gmail.com>
 License: Apache-2.0
 Project-URL: Repository, https://github.com/AnswerDotAI/fastllm

python_fastllm-0.0.47.dist-info/RECORD

@@ -0,0 +1,17 @@
+fastllm/__init__.py,sha256=AsmunnRJMjLeGqFnegMHf36qWFuc3ZMLADqDdrpYD2I,131
+fastllm/_modidx.py,sha256=OQDybSzrNmP5deiYtA14HV3rJsoRTR_0NPU5019rVAI,41130
+fastllm/acomplete.py,sha256=N4JnvuJwVCPc6iqbPuclJmcKFATmRytkUy9D3HwBPpY,10363
+fastllm/anthropic.py,sha256=udojlLuritp90JQlH-dGHcWRpzgnO1mZYFYtbt2F5IA,17015
+fastllm/chat.py,sha256=W8PPpZ95Az7wzLgQ15u3HMroWBVXDoaUz871f0x7cEk,24842
+fastllm/codex.py,sha256=HZchfrGUgdf8ayhtOFbIRmh9YmIqfQBwqviAEeir4Uo,161
+fastllm/gemini.py,sha256=DveWJNd78Pf2omC_t46iOzT84a-Lo3kWxchCKR3WsCA,15135
+fastllm/openai_chat.py,sha256=f11U-iaxGbBq0-Rjz17GhA1Vame5n9kMqsk1gkfDtIQ,11633
+fastllm/openai_responses.py,sha256=MUIBZY447tJ4Lc6saBPrVolXe8cdQdMK58YOtaJUHYk,14482
+fastllm/responses.py,sha256=zBzND8Sl_aE_Um1pvNKwzTtqcc6z0uxpvNjdavO_Pbs,18593
+fastllm/streaming.py,sha256=8qVtWeZ7NlP-9rup_4Ho0ol2dx3-XuGcIMXpZ1GYdEo,9079
+fastllm/types.py,sha256=3qXyiS431AlSSn8GyGCNDflZxMWPeIWirp8TIyhIu_A,19146
+python_fastllm-0.0.47.dist-info/METADATA,sha256=KuhdYwKV_gWivBjwBpjNR794DOJlfRPFSkNGOW51omE,21143
+python_fastllm-0.0.47.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_fastllm-0.0.47.dist-info/entry_points.txt,sha256=_cVRbpVkvyxdZfR7UCXa0lIXZtTSsZQWoBPhDwMqrHs,80
+python_fastllm-0.0.47.dist-info/top_level.txt,sha256=F8qodL7nEGUHGmzzqfhNKCTIr1i0D6cvudOnm3z7o0Y,8
+python_fastllm-0.0.47.dist-info/RECORD,,

python_fastllm-0.0.45.dist-info/RECORD

@@ -1,17 +0,0 @@
-fastllm/__init__.py,sha256=1FIai9vCI4Wk-TozHDezQYiz9cdNhuIl94Olnuvc0eo,131
-fastllm/_modidx.py,sha256=zvw4lGfv-nxMOrYfsRvX3rXyOnFBOTAOW4fDpIdtzdo,40195
-fastllm/acomplete.py,sha256=N4JnvuJwVCPc6iqbPuclJmcKFATmRytkUy9D3HwBPpY,10363
-fastllm/anthropic.py,sha256=udojlLuritp90JQlH-dGHcWRpzgnO1mZYFYtbt2F5IA,17015
-fastllm/chat.py,sha256=JBeSSN4_VWIbBMWvXMribaMeawGHiS34vpk2FA0KDvE,25113
-fastllm/codex.py,sha256=HZchfrGUgdf8ayhtOFbIRmh9YmIqfQBwqviAEeir4Uo,161
-fastllm/gemini.py,sha256=DveWJNd78Pf2omC_t46iOzT84a-Lo3kWxchCKR3WsCA,15135
-fastllm/openai_chat.py,sha256=f11U-iaxGbBq0-Rjz17GhA1Vame5n9kMqsk1gkfDtIQ,11633
-fastllm/openai_responses.py,sha256=yqwB4kdpWTMXfJfhT58CrJmpbkVWdgiHiZDLtrbtxqo,14369
-fastllm/responses.py,sha256=71SOGFa77YoWJ_9K4ZvmEh_2zIGVzq030krL3Ql_W9k,16237
-fastllm/streaming.py,sha256=8qVtWeZ7NlP-9rup_4Ho0ol2dx3-XuGcIMXpZ1GYdEo,9079
-fastllm/types.py,sha256=vLga_hWzsWKUKVHvUp577hHnShff_y2WQsAp0jnZsuE,19892
-python_fastllm-0.0.45.dist-info/METADATA,sha256=qHfFt2AW0BWX__LrbhD6OQRgG6PlmMcZrYIYojR2VP8,21143
-python_fastllm-0.0.45.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_fastllm-0.0.45.dist-info/entry_points.txt,sha256=_cVRbpVkvyxdZfR7UCXa0lIXZtTSsZQWoBPhDwMqrHs,80
-python_fastllm-0.0.45.dist-info/top_level.txt,sha256=F8qodL7nEGUHGmzzqfhNKCTIr1i0D6cvudOnm3z7o0Y,8
-python_fastllm-0.0.45.dist-info/RECORD,,