python-fastllm 0.0.47__tar.gz → 0.0.49__tar.gz

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/PKG-INFO

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

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/fastllm/__init__.py

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

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/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'),
@@ -323,7 +338,7 @@ d = { 'settings': { 'branch': 'main',
                                '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._flat_rates': ('types.html#_flat_rates', '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'),

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/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'),
@@ -66,10 +67,10 @@ def _codex_mtime_policy():
 
 # %% ../nbs/06_acomplete.ipynb #79075d95
 @flexicache(_codex_mtime_policy())
-def mk_client(model=None, vendor_name=None, api_name=None, api_key=None, base_url=None, xtra_hdrs=None,
+def mk_client(model=None, vendor_name=None, api_name=None, api_key=None, oauth_token=None, base_url=None, xtra_hdrs=None,
     timeout=httpx2.Timeout(connect=30, read=300, write=30, pool=10)):
     err_msg = f"please pass a valid one vendor: {', '.join(list(vendor_mapping))} or pass `api_name`,`base_url` and `api_key`"
-    if not vendor_name and not api_name and not (base_url and api_key):
+    if not vendor_name and not api_name and not (base_url and (api_key or oauth_token)):
         v, m = split_vendor(model)
         if v in vendor_mapping: vendor_name, model = v, m
     if vendor_name:
@@ -77,17 +78,17 @@ def mk_client(model=None, vendor_name=None, api_name=None, api_key=None, base_ur
         try:
             api_name, base_url, env_api_nm, *auth_json = vendor_mapping[vendor_name]
             base_url = override_base_url or base_url
-            if auth_json and not api_key and not os.getenv(env_api_nm):
+            if auth_json and not api_key and not oauth_token and not os.getenv(env_api_nm):
                 fn,keys = auth_json[0]  # pyright: ignore[reportAssignmentType]
                 auth_fn = Path(fn).expanduser()
                 if auth_fn.exists(): api_key = nested_idx(json.loads(auth_fn.read_text()), *keys)
-            api_key = get_api_key(api_key, env_api_nm)
+            if not oauth_token: api_key = get_api_key(api_key, env_api_nm)
         except KeyError: raise ValueError(f"Unknown vendor '{vendor_name}', {err_msg}")
-    elif base_url and api_key: vendor_name, api_name = ifnone(vendor_name, 'custom'), ifnone(api_name, 'openai_chat')
+    elif base_url and (api_key or oauth_token): vendor_name, api_name = ifnone(vendor_name, 'custom'), ifnone(api_name, 'openai_chat')
     elif (api_name:=infer_api_name(model)):  base_url, vendor_name = vendor_mapping[api_name][1], api_name
     else: raise ValueError(f"Model {model} can't be auto resolved, {err_msg}")
     api = api_registry[api_name]
-    hdrs = merge(api.get_hdrs(api_key), ifnone(xtra_hdrs, {}))
+    hdrs = merge(api.get_hdrs(api_key, oauth_token), ifnone(xtra_hdrs, {}))
     cli = AsyncHttpCli(base_url, base_headers=hdrs, timeout=timeout)
     return cli, api_name, vendor_name
 
@@ -154,16 +155,19 @@ async def _retry_stream(mk_gen, retries=2, retry_delay=0.5):
 
 # %% ../nbs/06_acomplete.ipynb #2379ec94
 @delegates(payload_kwargs)
-async def acomplete(msgs, model, api_name=None, vendor_name=None, api_key=None, base_url=None, endpoint=None, xtra_body=None, xtra_hdrs=None,
+async def acomplete(msgs, model, api_name=None, vendor_name=None, api_key=None, oauth_token=None, base_url=None, endpoint=None, xtra_body=None, xtra_hdrs=None,
     stream=False, previous_response_id=None, stop_callables=None, retries=2, retry_delay=0.5, **kwargs):
     "Unified completion across different APIs."
-    if not vendor_name and not api_name and not (base_url and api_key):
+    if api_key and oauth_token: raise ValueError('Pass `api_key` or `oauth_token`, not both: a request has one identity')
+    if not vendor_name and not api_name and not (base_url and (api_key or oauth_token)):
         v, m = split_vendor(model)
         if v in vendor_mapping: vendor_name, model = v, m
         elif v: api_name, model = v, m  # a registered transport api (e.g. claude_code): not an HTTP vendor
     own = api_name in api_registry and not hasattr(api_registry[api_name], 'endpoint') if api_name else False
-    if own: vendor_name = ifnone(vendor_name, api_name)  # an own-transport api: no HTTP client to build
-    else: cli, api_name, vendor_name = mk_client(model=model, vendor_name=vendor_name, api_name=api_name, api_key=api_key, base_url=base_url, xtra_hdrs=xtra_hdrs)
+    if own:
+        vendor_name = ifnone(vendor_name, api_name)  # an own-transport api: no HTTP client to build
+        if oauth_token: kwargs['oauth_token'] = oauth_token  # its `mk_payload` applies the user's token itself
+    else: cli, api_name, vendor_name = mk_client(model=model, vendor_name=vendor_name, api_name=api_name, api_key=api_key, oauth_token=oauth_token, base_url=base_url, xtra_hdrs=xtra_hdrs)
     api = api_registry[api_name]
     if previous_response_id is not None:
         if not getattr(api, 'supports_previous_response_id', False):

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/fastllm/anthropic.py

@@ -322,8 +322,12 @@ def mk_payload(msgs, model, **kwargs):
     return payload
 
 # %% ../nbs/04_anthropic.ipynb #60d52c1f
-def get_hdrs(api_key=None):
-    return {"x-api-key": get_api_key(api_key, 'ANTHROPIC_API_KEY'), "anthropic-version": "2023-06-01"}
+def get_hdrs(api_key=None, oauth_token=None):
+    "An OAuth token travels as a bearer under Anthropic's OAuth beta; an API key as `x-api-key`"
+    hdrs = {"anthropic-version": "2023-06-01"}
+    if oauth_token: return hdrs | {"Authorization": f"Bearer {oauth_token}", "anthropic-beta": "oauth-2025-04-20"}
+    return hdrs | {"x-api-key": get_api_key(api_key, 'ANTHROPIC_API_KEY')}
+
 
 # %% ../nbs/04_anthropic.ipynb #0d03643a
 def cost(usage, m):

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/fastllm/chat.py

@@ -168,6 +168,7 @@ class AsyncChat:
         api_name=None,            # API to use, one of ApiName: openai (responses), openai_chat, anthropic, gemini
         vendor_name=None,         # Vendor name, one of vendor_mapping which resolves api_base/api_key automatically
         api_key=None,             # API key when model can't be resolved or vendor_name is not known or codex
+        oauth_token=None,         # A subscription's OAuth token (Codex, Claude Code) in place of an API key
         base_url=None,            # API base url when model can't be resolved or vendor_name is not known
         endpoint=None,            # Override the transport's request path, for a server mounting Responses at a custom location
         extra_headers=None,       # Extra HTTP headers for custom providers
@@ -178,7 +179,7 @@ class AsyncChat:
         default_cbs=True          # Whether to include default callbacks
     ):
         "LiteLLM chat client."
-        if not vendor_name and not api_name and not (base_url and api_key):
+        if not vendor_name and not api_name and not (base_url and (api_key or oauth_token)):
             v, model = split_vendor(model)
             if v in vendor_mapping: vendor_name = v
             elif v: api_name = v  # a registered transport api (e.g. claude_code)
@@ -248,6 +249,7 @@ def _prep_call(self:AsyncChat, search, max_tokens, kwargs, stream=False, think=N
     if self.api_name:      kwargs['api_name'] = self.api_name
     if self.vendor_name:   kwargs['vendor_name'] = self.vendor_name
     if self.api_key:       kwargs['api_key'] = self.api_key
+    if self.oauth_token:   kwargs['oauth_token'] = self.oauth_token
     if self.base_url:      kwargs['base_url'] = self.base_url
     if self.endpoint:      kwargs['endpoint'] = self.endpoint
     if self.extra_headers: kwargs['xtra_hdrs'] = self.extra_headers

python_fastllm-0.0.49/fastllm/codex.py

@@ -0,0 +1,118 @@
+"""ChatGPT subscription tokens for the Codex backend"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/05_codex.ipynb.
+
+# %% auto #0
+__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())))

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/fastllm/gemini.py

@@ -267,9 +267,12 @@ def mk_payload(msgs, model, **kwargs):
     return payload
 
 # %% ../nbs/05_gemini.ipynb #60d52c1f
-def get_hdrs(api_key=None):
+def get_hdrs(api_key=None, oauth_token=None):
+    "Bearer auth for an OAuth token; otherwise the API key header"
+    if oauth_token: return {"Authorization": f"Bearer {oauth_token}"}
     return {"x-goog-api-key": get_api_key(api_key, 'GEMINI_API_KEY')}
 
+
 # %% ../nbs/05_gemini.ipynb #4ee3891f
 def cost(usage, m):
     raw = usage.raw

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/fastllm/openai_chat.py

@@ -198,7 +198,10 @@ def mk_payload(msgs, model, **kwargs):
     return payload
 
 # %% ../nbs/03_oai_chat.ipynb #16e813d2
-def get_hdrs(api_key=None): return {"Authorization": f"Bearer {get_api_key(api_key, 'OPENAI_API_KEY')}"}
+def get_hdrs(api_key=None, oauth_token=None):
+    "Bearer auth: an OAuth access token, or else an API key from the argument or the environment"
+    return {"Authorization": f"Bearer {oauth_token or get_api_key(api_key, 'OPENAI_API_KEY')}"}
+
 
 # %% ../nbs/03_oai_chat.ipynb #f89e2bf6
 def cost(usage, m):

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/fastllm/openai_responses.py

@@ -256,7 +256,10 @@ def mk_payload(msgs, model, **kwargs):
     return payload
 
 # %% ../nbs/02_oai_responses.ipynb #529fd4bc
-def get_hdrs(api_key=None): return {"Authorization": f"Bearer {get_api_key(api_key, 'OPENAI_API_KEY')}"}
+def get_hdrs(api_key=None, oauth_token=None):
+    "Bearer auth: an OAuth access token, or else an API key from the argument or the environment"
+    return {"Authorization": f"Bearer {oauth_token or get_api_key(api_key, 'OPENAI_API_KEY')}"}
+
 
 # %% ../nbs/02_oai_responses.ipynb #a907ffa8
 def cost(usage, m):

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/fastllm/responses.py

@@ -148,9 +148,10 @@ 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, server_tools=None):
+    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
@@ -159,7 +160,7 @@ class ResponseTurn(BasicRepr):
 # %% ../nbs/06a_responses.ipynb #a648297f
 class AsyncResponses:
     "Run individual Responses turns over FastLLM."
-    def prepare(self, body, previous=None, server_tools=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')
@@ -174,13 +175,13 @@ class AsyncResponses:
         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,
-            {f.__name__: f for f in server_tools or []})
+            {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, having received its first chunk"
+    "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 {}
     tools = list(body.get('tools') or []) + [dict(type='function', **get_schema(f, pname='parameters')) for f in turn.server_tools.values()]
@@ -188,7 +189,7 @@ async def call(self:AsyncResponses, turn):
     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'))
-    stream = 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
@@ -221,7 +222,7 @@ async def server_results(self:AsyncResponses, turn, comp):
 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 = self.prepare(turn.body | dict(input=outputs), self.state(turn, comp), turn.server_tools.values(), **turn.call_kwargs)
     nxt.id = turn.id
     return nxt
 

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/fastllm/types.py

@@ -300,14 +300,14 @@ register_model_info('muse-spark-1.1', vendor_name='meta_ai', **modern_llm, max_i
 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)
 
-def _rm_ctx_tiers(vendor_name, model):
-    "Drop upstream context-tier rates, which would otherwise override flat subscription pricing"
+def _flat_rates(vendor_name, model):
+    "Keep only the flat subscription rates: drop the upstream context, cache-TTL and service-tier variants that would otherwise apply"
     info = model_info_registry[vendor_name, model]
-    for k in [k for k in info if re.search(r'_above_\d+k_tokens', k)]: del info[k]
+    for k in [k for k in info if 'cost' in k and k not in codex_pricing and k != 'search_context_cost_per_query']: del info[k]
 
 for model in (codex54, codex54m, codex55):
     register_model_info(model, 'codex', base=model, base_vendor_name='chatgpt', supports_web_search=True, max_input_tokens=256000, **codex_pricing)
-    _rm_ctx_tiers('codex', model)
+    _flat_rates('codex', model)
 
 register_model_info(codex53spark, 'codex', **codex_pricing,
     supports_vision=False, supports_image_input=False, supports_web_search=True, supports_reasoning=True, supports_function_calling=True,
@@ -318,6 +318,7 @@ register_model_info(codex53spark, 'codex', **codex_pricing,
 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)
+    _flat_rates('claude_code', model)
 
 # %% ../nbs/00_types.ipynb #bb0c4c2a
 sol,terra,luna = gpt56s = 'gpt-5.6-sol gpt-5.6-terra gpt-5.6-luna'.split()
@@ -325,7 +326,7 @@ sol,terra,luna = gpt56s = 'gpt-5.6-sol gpt-5.6-terra gpt-5.6-luna'.split()
 # 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:
     register_model_info(model, 'codex', base=model, base_vendor_name='openai', max_input_tokens=371_000, **codex_pricing)
-    _rm_ctx_tiers('codex', model)
+    _flat_rates('codex', model)
 
 # %% ../nbs/00_types.ipynb #24cc47ec
 def get_model_pricing(mn, vendor_name, million=True):

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/pyproject.toml

@@ -17,6 +17,9 @@ classifiers = [
 ]
 dependencies = ['fastcore>=2.1.18', 'aidialog>=0.0.10', 'fasttransport>=0.0.2', 'pillow']
 
+[project.scripts]
+fastllm-auth = "fastllm.codex:main"
+
 [project.urls]
 Repository = "https://github.com/AnswerDotAI/fastllm"
 

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/python_fastllm.egg-info/PKG-INFO

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

{python_fastllm-0.0.47 → python_fastllm-0.0.49}/python_fastllm.egg-info/entry_points.txt

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

python_fastllm-0.0.47/fastllm/codex.py

@@ -1,7 +0,0 @@
-# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/05_codex.ipynb.
-
-# %% auto #0
-__all__ = []
-
-# %% ../nbs/05_codex.ipynb #a1d088d2
-from fastcore.utils import *