python-fastllm 0.0.46__py3-none-any.whl → 0.0.48__py3-none-any.whl

fastllm/__init__.py

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

fastllm/_modidx.py

@@ -120,7 +120,22 @@ d = { 'settings': { 'branch': 'main',
                               'fastllm.chat.stop_reason': ('chat.html#stop_reason', 'fastllm/chat.py'),
                               'fastllm.chat.structured': ('chat.html#structured', 'fastllm/chat.py'),
                               'fastllm.chat.think_sep': ('chat.html#think_sep', 'fastllm/chat.py')},
-            'fastllm.codex': {},
+            'fastllm.codex': { 'fastllm.codex._merge_tokens': ('codex.html#_merge_tokens', 'fastllm/codex.py'),
+                               'fastllm.codex._post': ('codex.html#_post', 'fastllm/codex.py'),
+                               'fastllm.codex._token_grant': ('codex.html#_token_grant', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_auth': ('codex.html#codex_auth', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_auth_path': ('codex.html#codex_auth_path', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_device_code': ('codex.html#codex_device_code', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_device_tokens': ('codex.html#codex_device_tokens', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_info': ('codex.html#codex_info', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_login': ('codex.html#codex_login', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_refresh': ('codex.html#codex_refresh', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_token': ('codex.html#codex_token', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_tokens': ('codex.html#codex_tokens', 'fastllm/codex.py'),
+                               'fastllm.codex.jwt_claims': ('codex.html#jwt_claims', 'fastllm/codex.py'),
+                               '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._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.acollect_stream': ('gemini.html#acollect_stream', 'fastllm/gemini.py'),
@@ -237,6 +252,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 +335,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 +356,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/acomplete.py

@@ -13,6 +13,7 @@ from fasttransport.core import AsyncHttpCli
 from fasttransport.errors import APIError
 
 from .types import *
+from .codex import codex_auth_path
 from aidialog.msg_parts import (Part, PartType, Msg, Text, Thinking, ToolUse, ToolResult, InputImage, InputAudio, InputVideo,
     InputFile, mk_tool_res_msg, Completion)
 from .streaming import *
@@ -22,7 +23,7 @@ from .anthropic import *
 from .gemini import *
 
 # %% ../nbs/06_acomplete.ipynb #32ee2546
-_codex_path = os.getenv('CODEX_AUTH_PATH', '~/.codex/auth.json')
+_codex_path = codex_auth_path()
 _codex_json = _codex_path, ('tokens','access_token')
 vendor_mapping = {
     "openai":       ('openai', 'https://api.openai.com/v1', 'OPENAI_API_KEY'),
@@ -162,7 +163,9 @@ async def acomplete(msgs, model, api_name=None, vendor_name=None, api_key=None,
         if v in vendor_mapping: vendor_name, model = v, m
         elif v: api_name, model = v, m  # a registered transport api (e.g. claude_code): not an HTTP vendor
     own = api_name in api_registry and not hasattr(api_registry[api_name], 'endpoint') if api_name else False
-    if own: vendor_name = ifnone(vendor_name, api_name)  # an own-transport api: no HTTP client to build
+    if own:
+        vendor_name = ifnone(vendor_name, api_name)  # an own-transport api: no HTTP client to build
+        if api_key: kwargs['api_key'] = api_key  # its `mk_payload` applies a per-user credential itself
     else: cli, api_name, vendor_name = mk_client(model=model, vendor_name=vendor_name, api_name=api_name, api_key=api_key, base_url=base_url, xtra_hdrs=xtra_hdrs)
     api = api_registry[api_name]
     if previous_response_id is not None:

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):

fastllm/codex.py

@@ -1,7 +1,118 @@
+"""ChatGPT subscription tokens for the Codex backend"""
+
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/05_codex.ipynb.
 
 # %% auto #0
-__all__ = []
+__all__ = ['SKEW_SECS', 'jwt_claims', 'mk_jwt', 'token_expired', 'codex_tokens', 'codex_info', 'codex_refresh', 'codex_token',
+           'codex_auth_path', 'codex_auth', 'codex_device_code', 'codex_device_tokens', 'codex_login', 'main']
 
 # %% ../nbs/05_codex.ipynb #a1d088d2
+import asyncio, base64, json, sys, time, httpx2
+from fastcore.aio import wait_until
 from fastcore.utils import *
+
+
+# %% ../nbs/05_codex.ipynb #aa7f9d4f
+_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann'
+_AUTH = 'https://auth.openai.com'
+SKEW_SECS = 60
+
+# %% ../nbs/05_codex.ipynb #2008472d
+def jwt_claims(token):
+    "The payload of JWT `token`, decoded without verification"
+    payload = token.split('.')[1]
+    return json.loads(base64.urlsafe_b64decode(payload + '='*(-len(payload)%4)))
+
+# %% ../nbs/05_codex.ipynb #fdba8e96
+def mk_jwt(**claims):
+    "An unsigned JWT carrying `claims`, shaped like an access token; for examples and tests"
+    enc = lambda o: base64.urlsafe_b64encode(json.dumps(o).encode()).decode().rstrip('=')
+    return f"{enc(dict(alg='RS256', typ='JWT'))}.{enc(claims)}.sig"
+
+# %% ../nbs/05_codex.ipynb #6b6a339d
+def token_expired(token, skew=SKEW_SECS):
+    "Is JWT `token` expired, or within `skew` seconds of expiring?"
+    try: exp = jwt_claims(token)['exp']
+    except (ValueError, KeyError, IndexError): return True
+    return time.time() >= exp - skew
+
+# %% ../nbs/05_codex.ipynb #099399d5
+def codex_tokens(auth):
+    "The `tokens` block of an `auth.json` dict (or an already-unwrapped block), checked for the keys a refresh needs"
+    if not isinstance(auth, dict): raise ValueError('Codex auth must be a JSON object')
+    tokens = auth.get('tokens', auth)
+    missing = [k for k in ('access_token', 'refresh_token') if not tokens.get(k)]
+    if missing: raise ValueError(f"Codex auth is missing {', '.join(missing)}")
+    return tokens
+
+# %% ../nbs/05_codex.ipynb #46864051
+def codex_info(tokens):
+    "Plan type and expiry time of the access token in `tokens`"
+    claims = jwt_claims(tokens['access_token'])
+    return dict(plan=claims.get('https://api.openai.com/auth', {}).get('chatgpt_plan_type'), expires=claims.get('exp'))
+
+# %% ../nbs/05_codex.ipynb #28410636
+async def _post(path, form=False, **body):
+    "POST `body` to the OpenAI auth server at `path`, as a form or as JSON, returning the JSON reply"
+    async with httpx2.AsyncClient() as cli: r = await cli.post(f'{_AUTH}{path}', **(dict(data=body) if form else dict(json=body)))
+    r.raise_for_status()
+    return r.json()
+
+def _merge_tokens(tokens, new): return {**tokens, **{k: new[k] for k in ('access_token', 'id_token', 'refresh_token') if k in new}}
+
+async def _token_grant(tokens, form=False, **grant):
+    "The token block after `grant` at the token endpoint, merged over `tokens`; the exchange of a sign-in code is form-encoded, a refresh JSON"
+    return _merge_tokens(tokens, await _post('/oauth/token', form=form, client_id=_CLIENT_ID, **grant))
+
+# %% ../nbs/05_codex.ipynb #48efd465
+async def codex_refresh(tokens):
+    "Exchange the refresh token in `tokens` for a new token block"
+    return await _token_grant(tokens, grant_type='refresh_token', refresh_token=tokens['refresh_token'], scope='openid profile email')
+
+# %% ../nbs/05_codex.ipynb #be590818
+async def codex_token(tokens, force_refresh=False):
+    "A valid access token from `tokens`, and the refreshed block to store when a refresh happened (else `None`)"
+    if not force_refresh and not token_expired(tokens['access_token']): return tokens['access_token'], None
+    tokens = await codex_refresh(tokens)
+    return tokens['access_token'], tokens
+
+# %% ../nbs/05_codex.ipynb #ea6c1e6a
+def codex_auth_path(): return Path(os.environ.get('CODEX_AUTH_PATH', '~/.codex/auth.json')).expanduser()
+
+async def codex_auth(force_refresh=False):
+    "A valid access token from the local Codex login, refreshing the file when needed"
+    path = codex_auth_path()
+    data = json.loads(path.read_text())
+    token,new = await codex_token(codex_tokens(data), force_refresh)
+    if new: path.write_text(json.dumps({**data, 'tokens':new}, indent=2))
+    return token
+
+# %% ../nbs/05_codex.ipynb #216c81ae
+_DEVICE = '/api/accounts/deviceauth'
+async def codex_device_code():
+    "Start a device sign-in: the page and code to show the user, and what the poll needs"
+    r = await _post(f'{_DEVICE}/usercode', client_id=_CLIENT_ID)
+    return dict(url=f'{_AUTH}/codex/device', code=r['user_code'], device_auth_id=r['device_auth_id'], interval=int(r.get('interval') or 5))
+
+# %% ../nbs/05_codex.ipynb #9ada6ae8
+async def codex_device_tokens(dev, timeout=15*60):
+    "Wait for the user to enter the code from `dev`, then exchange the grant for a token block"
+    async def _poll():
+        try: return await _post(f'{_DEVICE}/token', device_auth_id=dev['device_auth_id'], user_code=dev['code'])
+        except httpx2.HTTPStatusError as e:
+            if e.response.status_code in (403, 404): return None
+            raise
+    grant = await wait_until(_poll, 'the sign-in to complete', timeout, sleep=dev['interval'])
+    return await _token_grant({}, form=True, grant_type='authorization_code', code=grant['authorization_code'], redirect_uri=f'{_AUTH}/deviceauth/callback',
+        code_verifier=grant['code_verifier'])
+
+# %% ../nbs/05_codex.ipynb #0ca00e36
+async def codex_login():
+    "Sign in to ChatGPT with a device code, returning the token block"
+    dev = await codex_device_code()
+    print(f"Open {dev['url']} and enter the code {dev['code']}", file=sys.stderr)
+    return await codex_device_tokens(dev)
+
+def main():
+    "`fastllm-auth`: sign in to ChatGPT and print the token block"
+    print(json.dumps(asyncio.run(codex_login())))

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,19 @@ 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, call_kwargs=None):
+        store_attr()
+        if server_tools is None: self.server_tools = {}
+        if call_kwargs is None: self.call_kwargs = {}
 
     @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, **kwargs):
         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 +174,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 []}, kwargs)
+
 
 # %% ../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; the turn's `call_kwargs` reach `acomplete`"
     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, **turn.call_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(), **turn.call_kwargs)
+    nxt.id = turn.id
+    return nxt
 
 # %% ../nbs/06a_responses.ipynb #25502099
 def response_event(event_type, sequence_number, **kwargs):
@@ -278,22 +315,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,13 +3,14 @@
 # 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', 'fable51', 'gpt54', 'gpt54m', 'gpt55', 'codex54', 'codex54m', 'codex55',
-           'codex53spark', 'model_info_registry', 'modern_llm', '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', 'get_model_pricing', 'approx_pricing', 'is_deepseek_peak_hour', 'price_tier', 'tier_rate']
+__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
 import httpx2, base64, io
@@ -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"
@@ -217,50 +227,45 @@ 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
 # 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, max_input_tokens=1048576)
+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)
 
@@ -291,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)
@@ -322,7 +321,6 @@ 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()
-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.46.dist-info → python_fastllm-0.0.48.dist-info}/METADATA

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

python_fastllm-0.0.48.dist-info/RECORD

@@ -0,0 +1,17 @@
+fastllm/__init__.py,sha256=ioW91VJRYfSiEMjolhjzoNX1vPYfkbDKdrHXp79B9cQ,131
+fastllm/_modidx.py,sha256=jF1SdJd1qbfI_ksSmsrjKUgRHGrANOpxyqTn_hcZ2LY,42836
+fastllm/acomplete.py,sha256=Fb1GWkU6F7-bllbEEp7TPOzqmoWp309i5sJqYJbU6PM,10478
+fastllm/anthropic.py,sha256=udojlLuritp90JQlH-dGHcWRpzgnO1mZYFYtbt2F5IA,17015
+fastllm/chat.py,sha256=W8PPpZ95Az7wzLgQ15u3HMroWBVXDoaUz871f0x7cEk,24842
+fastllm/codex.py,sha256=r6auZ8egia83aGkWcF4132AzW4SsBvKeDwg_CxyXj9E,5808
+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=jcbKUwbEIsy7ngNcHUtv2bfYeDgqSysK_qWM-0LC9Mg,18767
+fastllm/streaming.py,sha256=8qVtWeZ7NlP-9rup_4Ho0ol2dx3-XuGcIMXpZ1GYdEo,9079
+fastllm/types.py,sha256=3qXyiS431AlSSn8GyGCNDflZxMWPeIWirp8TIyhIu_A,19146
+python_fastllm-0.0.48.dist-info/METADATA,sha256=meHtTkX0PRsmljM1a72zXLGwlFHm1IKkjroJKnAmc1g,21143
+python_fastllm-0.0.48.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_fastllm-0.0.48.dist-info/entry_points.txt,sha256=WkWd04F3xVYFP5bsexaQe9Se6uelwE5ULoTtHWreO0s,133
+python_fastllm-0.0.48.dist-info/top_level.txt,sha256=F8qodL7nEGUHGmzzqfhNKCTIr1i0D6cvudOnm3z7o0Y,8
+python_fastllm-0.0.48.dist-info/RECORD,,

{python_fastllm-0.0.46.dist-info → python_fastllm-0.0.48.dist-info}/entry_points.txt

@@ -1,3 +1,6 @@
+[console_scripts]
+fastllm-auth = fastllm.codex:main
+
 [fastaudit_import_allow]
 fastllm = fastllm
 

python_fastllm-0.0.46.dist-info/RECORD

@@ -1,17 +0,0 @@
-fastllm/__init__.py,sha256=vURwCxFsBCHTqkPwJTZzHL2iXy0aGMjAinI8E6iqZnI,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=zEMynkgqsShsfPwk2cMEl67QUBo0VVNG0n79VCvqvzw,25110
-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=H7xgkBFVwA-iyoqsQ68SIVADNRIwEQ5XpjQskiZ8I8w,20433
-python_fastllm-0.0.46.dist-info/METADATA,sha256=qK-cBjqv3-yAsrDhBXQGXr9yeJZGmhParYfRYMI29zM,21143
-python_fastllm-0.0.46.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_fastllm-0.0.46.dist-info/entry_points.txt,sha256=_cVRbpVkvyxdZfR7UCXa0lIXZtTSsZQWoBPhDwMqrHs,80
-python_fastllm-0.0.46.dist-info/top_level.txt,sha256=F8qodL7nEGUHGmzzqfhNKCTIr1i0D6cvudOnm3z7o0Y,8
-python_fastllm-0.0.46.dist-info/RECORD,,