python-fastllm 0.0.53__py3-none-any.whl → 0.0.55__py3-none-any.whl

fastllm/__init__.py

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

fastllm/_modidx.py

@@ -23,6 +23,7 @@ d = { 'settings': { 'branch': 'main',
                                    'fastllm.anthropic._ant_cc': ('anthropic.html#_ant_cc', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic._ant_part_type': ('anthropic.html#_ant_part_type', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic._sanid': ('anthropic.html#_sanid', 'fastllm/anthropic.py'),
+                                   'fastllm.anthropic._url_cite': ('anthropic.html#_url_cite', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic.acollect_stream': ('anthropic.html#acollect_stream', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic.apply_cache_idxs': ('anthropic.html#apply_cache_idxs', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic.collate_raw': ('anthropic.html#collate_raw', 'fastllm/anthropic.py'),
@@ -52,7 +53,7 @@ d = { 'settings': { 'branch': 'main',
                                    'fastllm.anthropic.norm_tr_parts': ('anthropic.html#norm_tr_parts', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic.norm_usage': ('anthropic.html#norm_usage', 'fastllm/anthropic.py'),
                                    'fastllm.anthropic.raw_msg': ('anthropic.html#raw_msg', 'fastllm/anthropic.py'),
-                                   'fastllm.anthropic.search_hits': ('anthropic.html#search_hits', 'fastllm/anthropic.py')},
+                                   'fastllm.anthropic.search_results': ('anthropic.html#search_results', 'fastllm/anthropic.py')},
             'fastllm.chat': { 'fastllm.chat.AsyncChat': ('chat.html#asyncchat', 'fastllm/chat.py'),
                               'fastllm.chat.AsyncChat.__call__': ('chat.html#asyncchat.__call__', 'fastllm/chat.py'),
                               'fastllm.chat.AsyncChat.__init__': ('chat.html#asyncchat.__init__', 'fastllm/chat.py'),
@@ -139,8 +140,10 @@ d = { 'settings': { 'branch': 'main',
                                'fastllm.codex.main': ('codex.html#main', 'fastllm/codex.py'),
                                'fastllm.codex.mk_jwt': ('codex.html#mk_jwt', 'fastllm/codex.py'),
                                'fastllm.codex.token_expired': ('codex.html#token_expired', 'fastllm/codex.py')},
-            'fastllm.gemini': { 'fastllm.gemini._gem_filter_sch': ('gemini.html#_gem_filter_sch', 'fastllm/gemini.py'),
+            'fastllm.gemini': { 'fastllm.gemini._fn_calls': ('gemini.html#_fn_calls', 'fastllm/gemini.py'),
+                                'fastllm.gemini._gem_filter_sch': ('gemini.html#_gem_filter_sch', 'fastllm/gemini.py'),
                                 'fastllm.gemini._gem_part_type': ('gemini.html#_gem_part_type', 'fastllm/gemini.py'),
+                                'fastllm.gemini._url_cite': ('gemini.html#_url_cite', 'fastllm/gemini.py'),
                                 'fastllm.gemini.acollect_stream': ('gemini.html#acollect_stream', 'fastllm/gemini.py'),
                                 'fastllm.gemini.collate_raw': ('gemini.html#collate_raw', 'fastllm/gemini.py'),
                                 'fastllm.gemini.cost': ('gemini.html#cost', 'fastllm/gemini.py'),
@@ -162,6 +165,7 @@ d = { 'settings': { 'branch': 'main',
                                 'fastllm.gemini.denorm_web_search': ('gemini.html#denorm_web_search', 'fastllm/gemini.py'),
                                 'fastllm.gemini.endpoint': ('gemini.html#endpoint', 'fastllm/gemini.py'),
                                 'fastllm.gemini.get_hdrs': ('gemini.html#get_hdrs', 'fastllm/gemini.py'),
+                                'fastllm.gemini.grounding': ('gemini.html#grounding', 'fastllm/gemini.py'),
                                 'fastllm.gemini.mk_payload': ('gemini.html#mk_payload', 'fastllm/gemini.py'),
                                 'fastllm.gemini.norm_finish': ('gemini.html#norm_finish', 'fastllm/gemini.py'),
                                 'fastllm.gemini.norm_parts': ('gemini.html#norm_parts', 'fastllm/gemini.py'),
@@ -253,8 +257,9 @@ d = { 'settings': { 'branch': 'main',
                                                                                         'fastllm/openai_responses.py'),
                                           'fastllm.openai_responses.norm_usage': ( 'oai_responses.html#norm_usage',
                                                                                    'fastllm/openai_responses.py'),
-                                          'fastllm.openai_responses.raw_msg': ( 'oai_responses.html#raw_msg',
-                                                                                'fastllm/openai_responses.py')},
+                                          'fastllm.openai_responses.raw_msg': ('oai_responses.html#raw_msg', 'fastllm/openai_responses.py'),
+                                          'fastllm.openai_responses.search_hits': ( 'oai_responses.html#search_hits',
+                                                                                    'fastllm/openai_responses.py')},
             'fastllm.responses': { 'fastllm.responses.AsyncResponses': ('responses.html#asyncresponses', 'fastllm/responses.py'),
                                    'fastllm.responses.AsyncResponses.__init__': ( 'responses.html#asyncresponses.__init__',
                                                                                   'fastllm/responses.py'),
@@ -317,7 +322,8 @@ d = { 'settings': { 'branch': 'main',
                                    'fastllm.responses.response_input': ('responses.html#response_input', 'fastllm/responses.py'),
                                    'fastllm.responses.response_object': ('responses.html#response_object', 'fastllm/responses.py'),
                                    'fastllm.responses.response_output': ('responses.html#response_output', 'fastllm/responses.py'),
-                                   'fastllm.responses.response_usage': ('responses.html#response_usage', 'fastllm/responses.py')},
+                                   'fastllm.responses.response_usage': ('responses.html#response_usage', 'fastllm/responses.py'),
+                                   'fastllm.responses.server_call_item': ('responses.html#server_call_item', 'fastllm/responses.py')},
             'fastllm.streaming': { 'fastllm.streaming.Delta': ('streaming.html#delta', 'fastllm/streaming.py'),
                                    'fastllm.streaming.Delta.__eq__': ('streaming.html#delta.__eq__', 'fastllm/streaming.py'),
                                    'fastllm.streaming.Delta.__hash__': ('streaming.html#delta.__hash__', 'fastllm/streaming.py'),

fastllm/acomplete.py

@@ -39,7 +39,7 @@ vendor_mapping = {
     "fireworks_ai": ('openai_chat', "https://api.fireworks.ai/inference/v1", "FIREWORKS_API_KEY"),
     "qwen":         ('openai_chat', "https://dashscope.aliyuncs.com/compatible-mode/v1", "QWEN_API_KEY"),
     "minimax":      ('anthropic', "https://api.minimax.io/anthropic", "MINIMAX_API_KEY"),
-    "meta_ai":      ('openai', "https://api.meta.ai/v1", "META_API_KEY"),
+    "meta":         ('openai', "https://api.meta.ai/v1", "META_API_KEY"),
     "zai":          ('openai_chat', "https://api.z.ai/api/paas/v4", "ZAI_API_KEY")}
 
 # %% ../nbs/06_acomplete.ipynb #e3ed40fb

fastllm/anthropic.py

@@ -1,7 +1,7 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/04_anthropic.ipynb.
 
 # %% auto #0
-__all__ = ['ant_tc_types', 'norm_tool_call', 'norm_tool_calls', 'norm_usage', 'finalize_usage', 'norm_finish', 'search_hits',
+__all__ = ['ant_tc_types', 'norm_tool_call', 'norm_tool_calls', 'norm_usage', 'finalize_usage', 'norm_finish', 'search_results',
            'norm_parts', 'raw_msg', 'norm_tr_parts', 'norm_sse_event', 'delta_index_fn', 'collate_raw',
            'acollect_stream', 'denorm_tool_use', 'denorm_assistant', 'denorm_tool', 'denorm_msgs', 'denorm_tool_schs',
            'denorm_tool_choice', 'denorm_reasoning', 'denorm_web_search', 'denorm_system', 'denorm_user',
@@ -15,7 +15,7 @@ from fastcore.meta import *
 from fasttransport.errors import api_error_from_event
 
 from .types import *
-from aidialog.msg_parts import (Part, PartType, mk_part, Msg, Completion, Text, Thinking, ToolUse, ToolResult, tool_text,
+from aidialog.msg_parts import (MdStr, Part, PartType, mk_part, Msg, Completion, Text, Thinking, ToolUse, ToolResult, tool_text,
                                 InputImage, InputAudio, InputVideo, InputFile, data_url)
 from .streaming import *
 from .streaming import mk_acollect_stream
@@ -63,30 +63,36 @@ def norm_finish(resp, tcs=None):
     r =  mp.get(reason, reason)
     return FinishReason.tool_calls if r==FinishReason.stop and any(~L(tcs).attrgot('server')) else r 
 
+# %% ../nbs/04_anthropic.ipynb #9796be28
+def search_results(parts, blocks):
+    "Give each server call the sources its `web_search_tool_result` block reports, one `title: url` line each, or the block's error code"
+    calls = {p.id: p for p in parts if isinstance(p, ToolUse) and p.server}
+    for b in blocks:
+        if b.get('type') != 'web_search_tool_result' or not (call := calls.get(b.get('tool_use_id'))): continue
+        res = b.get('content')
+        call.text = res.get('error_code', '') if isinstance(res, dict) else MdStr('\n'.join(f"{r.get('title', '')}: {r['url']}" for r in res if r.get('url')))
+    return parts
+
 # %% ../nbs/04_anthropic.ipynb #20d2e803
 def _ant_part_type(typ):
     "Map Anthropic content block type to canonical PartType."
     ant_parts_mapping = dict(text=PartType.text, thinking=PartType.thinking, redacted_thinking=PartType.thinking, tool_use=PartType.tool_use, server_tool_use=PartType.tool_use, mcp_tool_use=PartType.tool_use)
     return ant_parts_mapping.get(typ, typ)
 
-def search_hits(parts, blocks):
-    "Set each server call's `text` to the `title: url` lines of its result block, when the response has one"
-    calls = {p.id: p for p in parts if isinstance(p, ToolUse)}
-    for b in blocks:
-        if b.get('type', '').endswith('_tool_result') and (tc := calls.get(b.get('tool_use_id'))):
-            tc.text = '\n'.join(f"{r.get('title', '')}: {r.get('url', '')}" for r in b.get('content') or [] if isinstance(r, dict) and r.get('url'))
-    return parts
+def _url_cite(c): return dict(type='url_citation', url=c['url'], title=c.get('title', ''))
 
 def norm_parts(resp):
-    "Canonical parts of a response; a server tool's result block lives in the raw message, and as the call's `text`"
+    "Canonical parts of a response; a text block's web citations become `url_citation`s"
     parts = []
     for b in resp.get("content", []):
         typ = _ant_part_type(b.get("type", "text"))
         if   typ == PartType.thinking: parts.append(Thinking(b.get("thinking", ""), raw=b))
         elif typ == PartType.tool_use:
             if tc := norm_tool_call(b): parts.append(tc)
-        elif typ == PartType.text: parts.append(Text(b.get("text", ""), raw=b))
-    return search_hits(parts, resp.get("content", []))
+        elif typ == PartType.text:
+            cites = [_url_cite(c) for c in b.get('citations') or [] if c.get('url')]
+            parts.append(Text(b.get("text", ""), citations=cites, raw=b))
+    return search_results(parts, resp.get("content", []))
 
 # %% ../nbs/04_anthropic.ipynb #f24e52db
 def raw_msg(resp):
@@ -124,8 +130,7 @@ def norm_sse_event(ev, **kwargs):
         elif dtyp == "thinking_delta": thinking = d.get("thinking")
         elif dtyp == "input_json_delta":
             tcs = [ToolUse(id=str(ev.get("index", "")), name="", arguments={"_delta": d.get("partial_json", '')})]
-        elif dtyp == "citations_delta": 
-            citations = listify(d.get('citation',[]))
+        elif dtyp == "citations_delta": citations = [_url_cite(c) for c in listify(d.get('citation', [])) if c.get('url')]
     elif typ == "message_delta":
         fin = norm_finish(ev.get('delta'))
         return Delta(finish_reason=fin, usage=norm_usage(ev), raw=ev, **kwargs)
@@ -159,7 +164,7 @@ def collate_raw(deltas):
 async def acollect_stream(resp, **kwargs):
     res = mk_acollect_stream(norm_and_yield(resp, norm_sse_event), index_fn=delta_index_fn, api_name='anthropic', **kwargs)
     async for o in res:
-        if isinstance(o, Completion): search_hits(o.message.content, o.message.raw['content'])
+        if isinstance(o, Completion): search_results(o.message.content, o.message.raw['content'])
         yield o
 
 # %% ../nbs/04_anthropic.ipynb #bb11ab62

fastllm/gemini.py

@@ -1,21 +1,21 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/05_gemini.ipynb.
 
 # %% auto #0
-__all__ = ['api_ns', 'endpoint', 'norm_tool_calls', 'norm_usage', 'norm_finish', 'norm_parts', 'raw_msg', 'norm_sse_event',
-           'delta_index_fn', 'collate_raw', 'acollect_stream', 'denorm_tool_use', 'denorm_assistant', 'denorm_tool',
-           'denorm_msgs', 'denorm_tool_schs', 'denorm_tool_choice', 'denorm_reasoning', 'denorm_web_search',
-           'denorm_system', 'denorm_user', 'denorm_image', 'denorm_audio', 'denorm_video', 'denorm_file',
-           'denorm_tool_result', 'mk_payload', 'get_hdrs', 'cost']
+__all__ = ['api_ns', 'endpoint', 'grounding', 'norm_tool_calls', 'norm_usage', 'norm_finish', 'norm_parts', 'raw_msg',
+           'norm_sse_event', 'delta_index_fn', 'collate_raw', 'acollect_stream', 'denorm_tool_use', 'denorm_assistant',
+           'denorm_tool', 'denorm_msgs', 'denorm_tool_schs', 'denorm_tool_choice', 'denorm_reasoning',
+           'denorm_web_search', 'denorm_system', 'denorm_user', 'denorm_image', 'denorm_audio', 'denorm_video',
+           'denorm_file', 'denorm_tool_result', 'mk_payload', 'get_hdrs', 'cost']
 
 # %% ../nbs/05_gemini.ipynb #02afd3d7
-import json
+import html
 from collections import Counter
 from fastcore.utils import *
 from fastcore.meta import *
 from fasttransport.errors import api_error_from_event
 
 from .types import *
-from aidialog.msg_parts import (Part, PartType, Msg, Text, Thinking, ToolUse, ToolResult, tool_text,
+from aidialog.msg_parts import (MdStr, Part, PartType, Msg, Completion, Text, Thinking, ToolUse, ToolResult, tool_text,
                                 InputImage, InputAudio, InputVideo, InputFile, sys_text, part_txt, data_url, url_mime)
 from .streaming import *
 from .streaming import mk_acollect_stream
@@ -26,16 +26,30 @@ def endpoint(model, stream):
     return f'v1beta/{model}:{"streamGenerateContent" if stream else "generateContent"}', ({'alt': 'sse'} if stream else None)
 
 # %% ../nbs/05_gemini.ipynb #f1eb32f3
+def _url_cite(c): return dict(type='url_citation', url=c['web']['uri'], title=c['web'].get('title', ''))
+
+def grounding(cand):
+    "The `url_citation`s and the `google_search` call a candidate's `groundingMetadata` or `toolCall` parts describe, or `([], None)` without either; the call's `text` lists the sources and the Google Search suggestion links"
+    gm = cand.get('groundingMetadata') or {}
+    tcs = [p['toolCall'] for p in nested_idx(cand, 'content', 'parts') or [] if 'toolCall' in p]
+    if not gm and not tcs: return [], None
+    cites = [_url_cite(c) for c in gm.get('groundingChunks', []) if nested_idx(c, 'web', 'uri')]
+    chips = re.findall(r'<a class="chip" href="([^"]+)">([^<]*)</a>', nested_idx(gm, 'searchEntryPoint', 'renderedContent') or '')
+    queries = gm.get('webSearchQueries') or [q for tc in tcs for q in (tc.get('args') or {}).get('queries', [])]
+    lines = [f"{c['title']}: {c['url']}" for c in cites] + [f"Search suggestion: [{html.unescape(t)}]({html.unescape(u)})" for u,t in chips]
+    call = ToolUse(id='google_search', name='google_search', arguments=dict(queries=queries), server=True, text=MdStr('\n'.join(lines)))
+    return cites, call
+
+# %% ../nbs/05_gemini.ipynb #48de3125
+def _fn_calls(parts):
+    return [ToolUse(id=fc.get("id", f"call_{i}"), name=fc.get("name", ""), arguments=fc.get("args") or {}, raw={k:v for k,v in p.items() if k != "functionCall"})
+        for i,p in enumerate(parts) if (fc := p.get("functionCall"))]
+
 def norm_tool_calls(resp):
-    "Tool calls of a response: `functionCall` parts, and a `toolCall` part for a search the API ran itself"
-    out = []
-    for i,p in enumerate(nested_idx(resp, 'candidates', 0, 'content', 'parts') or []):
-        if fc := p.get("functionCall"):
-            raw = {k:v for k,v in p.items() if k != "functionCall"}
-            out.append(ToolUse(id=fc.get("id", f"call_{i}"), name=fc.get("name", ""), arguments=fc.get("args") or {}, raw=raw))
-        elif tc := p.get("toolCall"):
-            out.append(ToolUse(id=tc.get("id", f"call_{i}"), name=tc.get("toolType", "").lower(), arguments=tc.get("args") or {}, server=True))
-    return out
+    "Tool calls of a response: the `google_search` call its grounding describes, then its `functionCall` parts"
+    cand = nested_idx(resp, 'candidates', 0) or {}
+    _,call = grounding(cand)
+    return ([call] if call else []) + _fn_calls(nested_idx(cand, 'content', 'parts') or [])
 
 # %% ../nbs/05_gemini.ipynb #90504163
 def norm_usage(resp):
@@ -50,7 +64,7 @@ def norm_usage(resp):
     cand = nested_idx(resp, 'candidates', 0) or {}
     stu = {}
     if any("executableCode" in p for p in parts): stu["code_execution"] = sum(1 for p in parts if "executableCode" in p)
-    if n := ("groundingMetadata" in cand) + sum(1 for p in parts if 'toolCall' in p): stu["google_search"] = n
+    if call := grounding(cand)[1]: stu['google_search'] = len(call.arguments['queries'] or [1])
     if stu: usg['server_tool_use'] = stu
     return Usage(prompt_tokens=pt, completion_tokens=ct, total_tokens=tt,
                  cached_tokens=cached, reasoning_tokens=reasoning, raw=usg)
@@ -67,28 +81,26 @@ def norm_finish(resp, tcs=None):
 # %% ../nbs/05_gemini.ipynb #81c2ce3f
 def _gem_part_type(p):
     "Map Gemini part to canonical PartType."
-    if 'functionCall' in p or 'toolCall' in p: return PartType.tool_use
+    if 'functionCall' in p: return PartType.tool_use
     if 'executableCode' in p or 'codeExecutionResult' in p: return PartType.tool_result
     if p.get('thought'): return PartType.thinking
     return PartType.text
 
 def norm_parts(resp):
-    "Normalize Gemini generateContent response."
+    "Normalize Gemini generateContent response; a search's `toolCall` and `toolResponse` parts give way to the call `grounding` builds"
     c0 = nested_idx(resp, 'candidates', 0) or {}
+    cites,call = grounding(c0)
     tc_map = {tc.id: tc for tc in norm_tool_calls(resp)}
-    parts = []
+    parts = [call] if call else []
     for p in nested_idx(c0, 'content', 'parts') or []:
-        if 'toolResponse' in p: continue
+        if 'toolCall' in p or 'toolResponse' in p: continue
         typ = _gem_part_type(p)
         if typ == PartType.tool_use:
-            fc = p.get('functionCall') or p.get('toolCall') or {}
-            if tc := tc_map.get(fc.get('id')): parts.append(tc)
+            if tc := tc_map.get(p['functionCall'].get('id')): parts.append(tc)
         elif typ == PartType.thinking:    parts.append(Thinking(p.get("text",""), raw=p))
         elif typ == PartType.tool_result: parts.append(ToolResult(text=p.get("text",""), raw=p))
         else:                             parts.append(Text(p.get("text",""), raw=p))
-    if citations := c0.get('groundingMetadata'):
-        for p in parts:
-            if isinstance(p, Text): p.citations = citations
+    if txts := [p for p in parts if isinstance(p, Text)]: txts[0].citations = cites
     return parts
 
 # %% ../nbs/05_gemini.ipynb #3acc9538
@@ -105,9 +117,10 @@ def norm_sse_event(ev, **kwargs):
     parts = nested_idx(cand, 'content', 'parts') or []
     thinking = "".join(p.get("text","") for p in parts if p.get("thought") and "text" in p)
     txt = "".join(p.get("text","") for p in parts if not p.get("thought") and "text" in p)
-    tcs = norm_tool_calls(ev)
+    cites,call = grounding(cand) if 'groundingMetadata' in cand else ([], None)  # a search is reported once its grounding arrives
+    tcs = _fn_calls(parts) + ([call] if call else [])
     if ev.get("error"): raise api_error_from_event(ev)
-    return Delta(text=txt, thinking=thinking, tool_calls=tcs, citations=listify(cand.get('groundingMetadata', [])), finish_reason=finish_reason, usage=norm_usage(ev), raw=ev, **kwargs)
+    return Delta(text=txt, thinking=thinking, tool_calls=tcs, citations=cites, finish_reason=finish_reason, usage=norm_usage(ev), raw=ev, **kwargs)
 
 # %% ../nbs/05_gemini.ipynb #ebd6fdd4
 def delta_index_fn(d, typ, last_typ, last_idx):

fastllm/openai_responses.py

@@ -1,11 +1,11 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/02_oai_responses.ipynb.
 
 # %% auto #0
-__all__ = ['api_ns', 'norm_tool_call', 'norm_tool_calls', 'norm_usage', 'norm_finish', 'norm_parts', 'raw_msg', 'norm_sse_event',
-           'delta_index_fn', 'collate_raw', 'acollect_stream', 'denorm_tool_use', 'denorm_tool', 'denorm_assistant',
-           'denorm_msgs', 'denorm_tool_schs', 'denorm_tool_choice', 'denorm_reasoning', 'denorm_web_search',
-           'denorm_system', 'denorm_user', 'denorm_image', 'denorm_video', 'denorm_file', 'denorm_tool_result',
-           'mk_payload', 'get_hdrs', 'cost', 'fix_payload']
+__all__ = ['api_ns', 'norm_tool_call', 'norm_tool_calls', 'norm_usage', 'norm_finish', 'search_hits', 'norm_parts', 'raw_msg',
+           'norm_sse_event', 'delta_index_fn', 'collate_raw', 'acollect_stream', 'denorm_tool_use', 'denorm_tool',
+           'denorm_assistant', 'denorm_msgs', 'denorm_tool_schs', 'denorm_tool_choice', 'denorm_reasoning',
+           'denorm_web_search', 'denorm_system', 'denorm_user', 'denorm_image', 'denorm_video', 'denorm_file',
+           'denorm_tool_result', 'mk_payload', 'get_hdrs', 'cost', 'fix_payload']
 
 # %% ../nbs/02_oai_responses.ipynb #591f55b5
 import json
@@ -15,7 +15,7 @@ from fastcore.meta import *
 from fasttransport.errors import api_error_from_event
 
 from .types import *
-from aidialog.msg_parts import (Completion, Part, PartType, Msg, Text, Thinking, Refusal, ToolUse, ToolResult, tool_text,
+from aidialog.msg_parts import (Completion, Part, PartType, Msg, Text, Thinking, Refusal, ToolUse, ToolResult, tool_text, MdStr,
     InputImage, InputAudio, InputVideo, InputFile, mk_tool_res_msg, sys_text, part_txt, data_url)
 from .streaming import *
 from .streaming import mk_acollect_stream
@@ -26,10 +26,11 @@ def norm_tool_call(item):
     if typ == "function_call":
         raw = {k:v for k,v in item.items() if k not in ("call_id","name","arguments")}
         return ToolUse(id=item.get("call_id") or item["id"], name=item["name"], arguments=json.loads(item["arguments"]), raw=raw)
-    if typ.endswith("_call"):  # web_search_call, file_search_call, etc.
-        name = typ.removesuffix("_call")
-        raw = {k:v for k,v in item.items() if k not in ("id")}
-        return ToolUse(id=item.get("id",""), name=name, arguments=item.get("action", {}), server=True, raw=raw)
+    if typ.endswith("_call"):  # a call the server ran: OpenAI's hosted items carry an `action`, a Responses server's `server_tool_call` its `arguments` and `output` (`md` when that output is markdown)
+        raw = {k:v for k,v in item.items() if k not in ("id","name","arguments","output","action","md")}
+        args = json.loads(item["arguments"]) if "arguments" in item else item.get("action", {})
+        out = item.get("output")
+        return ToolUse(id=item.get("id",""), name=item.get("name") or typ.removesuffix("_call"), arguments=args, server=True, text=MdStr(out) if item.get("md") else out, raw=raw)
 
 def norm_tool_calls(resp):
     "Extract Responses API tool call items as normalized tool calls."
@@ -63,6 +64,14 @@ def norm_finish(resp, tcs=None):
     r =  mp.get(reason, reason)
     return FinishReason.tool_calls if r==FinishReason.stop and any(~L(tcs).attrgot('server')) else r 
 
+# %% ../nbs/02_oai_responses.ipynb #bbfb99b9
+def search_hits(parts):
+    "OpenAI reports no result for a hosted search, so a server call's empty `text` becomes the message's cited sources, one `title: url` line each"
+    hits = {c['url']: c.get('title', '') for p in parts if isinstance(p, Text) for c in p.citations or [] if c.get('url')}
+    for p in parts:
+        if isinstance(p, ToolUse) and p.server and not p.text: p.text = MdStr('\n'.join(f"{t}: {u}" for u,t in hits.items()))
+    return parts
+
 # %% ../nbs/02_oai_responses.ipynb #4ef27720
 def norm_parts(resp):
     parts = []
@@ -76,7 +85,7 @@ def norm_parts(resp):
         elif typ == "reasoning":
             for s in item["summary"]: parts.append(Thinking(s['text'], raw=item))
         elif typ == "function_call" or typ.endswith("_call"): parts.append(norm_tool_call(item))
-    return parts
+    return search_hits(parts)
 
 # %% ../nbs/02_oai_responses.ipynb #2aaab962
 def raw_msg(resp):
@@ -128,7 +137,9 @@ def collate_raw(deltas):
 @delegates(mk_acollect_stream, but=['index_fn', 'api_name'])
 async def acollect_stream(resp, **kwargs):
     res = mk_acollect_stream(norm_and_yield(resp, norm_sse_event), index_fn=delta_index_fn, api_name='openai', **kwargs)
-    async for o in res: yield o
+    async for o in res:
+        if isinstance(o, Completion): search_hits(o.message.content)
+        yield o
 
 # %% ../nbs/02_oai_responses.ipynb #9608e813
 def _sanid(id_str): return id_str[:64] # codex max 64 char limit

fastllm/responses.py

@@ -11,8 +11,9 @@ Every request is streamed. `_ResponseStream` only tracks the standard event gram
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/06a_responses.ipynb.
 
 # %% auto #0
-__all__ = ['ResponsesError', 'response_input', 'normalize_call_ids', 'response_output', 'response_usage', 'response_object',
-           'ResponseState', 'ResponseStore', 'ResponseTurn', 'AsyncResponses', 'response_event', 'pending_response']
+__all__ = ['ResponsesError', 'response_input', 'normalize_call_ids', 'server_call_item', 'response_output', 'response_usage',
+           'response_object', 'ResponseState', 'ResponseStore', 'ResponseTurn', 'AsyncResponses', 'response_event',
+           'pending_response']
 
 # %% ../nbs/06a_responses.ipynb #e16fc24e
 import asyncio, copy, json, secrets, time
@@ -22,7 +23,7 @@ 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, tool_text, msg2dict, dict2msg
+from aidialog.msg_parts import Msg, Text, ToolUse, ToolResult, InputImage, InputFile, Completion, MdStr, tool_text, msg2dict, dict2msg
 
 # %% ../nbs/06a_responses.ipynb #f904c16f
 class ResponsesError(Exception):
@@ -93,6 +94,13 @@ def normalize_call_ids(comp):
 # %% ../nbs/06a_responses.ipynb #ab1a57d7
 def _arguments(args): return args if isinstance(args, str) else json.dumps(args or {}, separators=(',', ':'))
 
+def server_call_item(part):
+    "The output item for a call the server ran, whether a host tool or the provider's own: a `server_tool_call` carrying its `arguments` and result `output`, marked `md` when that output is markdown"
+    item = dict(type='server_tool_call', name=part.name, arguments=_arguments(part.arguments), output=part.text or '')
+    if isinstance(part.text, MdStr): item['md'] = True
+    part._response_item_id = getattr(part, '_response_item_id', None) or _new_id('srv')
+    return dict(id=part._response_item_id, status='completed', **item)
+
 def response_output(comp):
     "Convert a Completion to Responses output items."
     output,msg = [],None
@@ -106,8 +114,9 @@ def response_output(comp):
             else:
                 msg['content'][0]['text'] += part.text or ''
                 msg['content'][0]['annotations'].extend(part.citations or [])
-        elif isinstance(part, ToolUse) and not part.server:
-            output.append(dict(id=getattr(part, '_response_item_id', None) or _new_id('fc'), type='function_call', status='completed',
+        elif isinstance(part, ToolUse):
+            if part.server: output.append(server_call_item(part))
+            else: output.append(dict(id=getattr(part, '_response_item_id', None) or _new_id('fc'), type='function_call', status='completed',
                 call_id=part.id, name=part.name, arguments=_arguments(part.arguments)))
     return output
 
@@ -337,13 +346,21 @@ def part_events(self:_ResponseStream, part):
 def done_events(self:_ResponseStream, comp):
     events = []
     if self.message_id is not None:
-        content = dict(type='output_text', text=self.text, annotations=[])
+        cites = [c for p in comp.message.content if isinstance(p, Text) for c in p.citations or []]
+        content = dict(type='output_text', text=self.text, annotations=cites)
         item = dict(id=self.message_id, type='message', status='completed', role='assistant', content=[content])
         events.append(self.event('response.output_text.done', item_id=self.message_id, output_index=self.message_index,
             content_index=0, text=self.text))
         events.append(self.event('response.content_part.done', item_id=self.message_id, output_index=self.message_index,
             content_index=0, part=content))
+        for i,c in enumerate(content['annotations']):
+            events.append(self.event('response.output_text.annotation.added', item_id=self.message_id, output_index=self.message_index,
+                content_index=0, annotation_index=i, annotation=c))
         events.append(self.event('response.output_item.done', output_index=self.message_index, item=item))
+    for part in comp.message.content:
+        if isinstance(part, ToolUse) and part.server:
+            events.append(self.event('response.output_item.done', output_index=self.next_index, item=server_call_item(part)))
+            self.next_index += 1
     for i,tc in enumerate(comp.tool_calls):
         if not tc.id and i < len(self.streamed_call_ids): tc.id = self.streamed_call_ids[i]
         tc._response_item_id = self.tool_item_ids.get(tc.id)
@@ -367,7 +384,8 @@ async def events(self:AsyncResponses, turn, finalize=None, stream=None):
             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)]
+            texts += [p for p in comp.message.content if isinstance(p, Text) or (isinstance(p, ToolUse) and p.server)]
+            texts += [ToolUse(id=r.id, name=r.name, arguments=r.arguments, server=True, text=r.text) for r in results]
             turn = self.server_turn(turn, comp, results)
         next_state = self.state(turn, comp, results)
         comp = copy.copy(comp)
@@ -381,7 +399,6 @@ async def events(self:AsyncResponses, turn, finalize=None, stream=None):
     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)
 
-
 # %% ../nbs/06a_responses.ipynb #cc32ce40
 @patch
 def serve(self:AsyncResponses, turn, finalize=None, stream=None, timeout=None):

fastllm/streaming.py

@@ -76,6 +76,7 @@ class PartAccum(BasicRepr):
                 if isinstance(p.arguments, str): p.arguments = json.loads(p.arguments) if p.arguments else {}
             elif merged and type(merged[-1]) is type(p) and isinstance(p, (Text, Thinking)):
                 merged[-1].text += p.text
+                if isinstance(p, Text): merged[-1].citations.extend(p.citations)
                 continue
             merged.append(p)
         return merged
@@ -163,7 +164,7 @@ async def mk_acollect_stream(it, index_fn, model=None, api_name=None, vendor_nam
         # Rest incl. tools, finish reason, usage is processed independently
         for tc in d.tool_calls:
             args = tc.arguments.get('_delta', tc.arguments)
-            _, idx = _proc(d, 'tool_use', ret=dict(id=tc.id, name=tc.name, arguments=args, server=tc.server, raw=tc.raw))
+            _, idx = _proc(d, 'tool_use', ret=dict(id=tc.id, name=tc.name, arguments=args, server=tc.server, text=tc.text, raw=tc.raw))
             if (isinstance(args, str) and args.endswith('}')) or (isinstance(args, dict) and '_delta' not in tc.arguments): # tool call ready
                 acc = part_accum.parts[idx]
                 if isinstance(args, str):
@@ -171,7 +172,6 @@ async def mk_acollect_stream(it, index_fn, model=None, api_name=None, vendor_nam
                     except json.JSONDecodeError: continue
                 acc.arguments = args
                 yield acc
-                if acc.server: yield ToolResult(id=acc.id, name=acc.name, arguments=args, server=True, text="Server tool call executed.")
         r = _proc(d, 'refusal')
         if r[0]: yield _mk_delta_part('refusal', r[0]['refusal'])
         if d.finish_reason: fin = d.finish_reason

fastllm/types.py

@@ -22,7 +22,6 @@ from fastcore.utils import *
 from PIL import Image as PImg
 from aidialog.msg_parts import Msg, Thinking, ToolUse, Completion, StopResponse, FullResponse
 
-
 # %% ../nbs/00_types.ipynb #802ad832
 class Usage(BasicRepr):
     "Normalized usage."
@@ -293,11 +292,6 @@ register_model_info('mimo-v2.5-pro-ultraspeed', vendor_name='mimo', **mimo_v25_c
 register_model_info('MiniMax-M3', vendor_name='minimax', **modern_llm, max_input_tokens=512_000, max_output_tokens=512_000, max_tokens=512_000,
     input_cost_per_token=0.3e-6, output_cost_per_token=1.2e-6, cache_read_input_token_cost=0.06e-6, supports_vision=True, supports_video_input=True)
 
-# %% ../nbs/00_types.ipynb #4e1b40b3
-register_model_info('muse-spark-1.1', vendor_name='meta_ai', **modern_llm, max_input_tokens=1_048_576, max_output_tokens=128000, max_tokens=128000,
-    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 #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)
@@ -332,8 +326,9 @@ for model in gpt56s:
 
 # %% ../nbs/00_types.ipynb #24cc47ec
 def get_model_pricing(mn, vendor_name, million=True):
+    "Token rates for a model, per million tokens by default; per-query and per-image prices are left out"
     return {k:round(v * (1e6 if million else 1), 6) for k,v in get_model_info(mn, vendor_name).items()
-        if 'cost' in k and isinstance(v,float) and 'priority' not in k}
+        if 'cost' in k and 'token' in k and isinstance(v,float) and 'priority' not in k}
 
 # %% ../nbs/00_types.ipynb #79304cd9
 def approx_pricing(nm, vendor_name, out=10, cache=80, inp=10, markup=0):

{python_fastllm-0.0.53.dist-info → python_fastllm-0.0.55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fastllm
-Version: 0.0.53
+Version: 0.0.55
 Author-email: Kerem Turgutlu <keremturgutlu@gmail.com>
 License: Apache-2.0
 Project-URL: Repository, https://github.com/AnswerDotAI/fastllm
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: fastcore>=2.1.18
-Requires-Dist: aidialog>=0.0.26
+Requires-Dist: aidialog>=0.0.27
 Requires-Dist: fasttransport>=0.0.2
 Requires-Dist: pillow
 

python_fastllm-0.0.55.dist-info/RECORD

@@ -0,0 +1,17 @@
+fastllm/__init__.py,sha256=iRT1X9KDx6ALQWPw-p0wlt7QqSDN3UqpvPe6xy9-niU,131
+fastllm/_modidx.py,sha256=qzUtLbjOche-GNbeNun3VRIQdcm5g4dUOCLJ6T9fG-w,46374
+fastllm/acomplete.py,sha256=64-k3LgLoX1EoWcHBS_-epZ-JvX5JL-As9QTo-WSzDc,10772
+fastllm/anthropic.py,sha256=vsWkmIxIh8j7LTPfLzgrNggOl_2LuRKKcdVhLfDDdRE,18748
+fastllm/chat.py,sha256=klji3SOYs5xyzrSFbNhy3uoQ2TSZ3a-8HTjvdRtaG5Q,25036
+fastllm/codex.py,sha256=r6auZ8egia83aGkWcF4132AzW4SsBvKeDwg_CxyXj9E,5808
+fastllm/gemini.py,sha256=978x7WDug5nSNvTOacap3bglgQhddahykFQvoOKOvhs,17571
+fastllm/openai_chat.py,sha256=n5INfDCsAZIiKUImWeaX6SJ_OAJ_uMhw20HUkgFgdgM,12379
+fastllm/openai_responses.py,sha256=O30JBRG0kTI31FPnzAOMEE8iiIsMBdAxVGoZys58Jn4,15288
+fastllm/responses.py,sha256=9gh-UlhfswCcP0RCzLuPT5meWNh9mF_OIivzCzZU94I,22726
+fastllm/streaming.py,sha256=DrqNJkMhyntFKokY6GF6oW3CjELrk5XWmnxwcApJUyM,8770
+fastllm/types.py,sha256=hET6SNjqC8Z5PasrZ4uU-OObIfs3QyI0ZPY4jE2rh1Q,19268
+python_fastllm-0.0.55.dist-info/METADATA,sha256=4S2QRq-6hLiji-8MTmAbzgXZvJ5k8U0SdVk8EC1-acA,18537
+python_fastllm-0.0.55.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_fastllm-0.0.55.dist-info/entry_points.txt,sha256=WkWd04F3xVYFP5bsexaQe9Se6uelwE5ULoTtHWreO0s,133
+python_fastllm-0.0.55.dist-info/top_level.txt,sha256=F8qodL7nEGUHGmzzqfhNKCTIr1i0D6cvudOnm3z7o0Y,8
+python_fastllm-0.0.55.dist-info/RECORD,,

python_fastllm-0.0.53.dist-info/RECORD

@@ -1,17 +0,0 @@
-fastllm/__init__.py,sha256=p94hx8eEtzJ2eou5yZY7R3C9ab8YAXbWNrFNQoK6S-s,131
-fastllm/_modidx.py,sha256=5WI8_unIttNYqjHBQBHf33C1OVgMgCcdO2SbdOk04Io,45637
-fastllm/acomplete.py,sha256=aP1ff9a7WKNhBd1kwKE2TJ-YyihLcdhd9-1Izi4wQP4,10772
-fastllm/anthropic.py,sha256=k0QeuRnl_CalfCq74WXN6llRQqRiAQ9d8ohn_0YYC7A,18386
-fastllm/chat.py,sha256=klji3SOYs5xyzrSFbNhy3uoQ2TSZ3a-8HTjvdRtaG5Q,25036
-fastllm/codex.py,sha256=r6auZ8egia83aGkWcF4132AzW4SsBvKeDwg_CxyXj9E,5808
-fastllm/gemini.py,sha256=zbxNmI1cMUJJ10xIfBqPqh38hAQ0exsFKkhTXvG2-eE,16281
-fastllm/openai_chat.py,sha256=n5INfDCsAZIiKUImWeaX6SJ_OAJ_uMhw20HUkgFgdgM,12379
-fastllm/openai_responses.py,sha256=zsaOjkQUZ-7iuGPc-UpvnM6oAyqW09BDYwZ_ma4-1Qo,14346
-fastllm/responses.py,sha256=ASTWk_dghOfJozQAm6QAZ8VnkGFA-sBLGVeS60DfP3E,21303
-fastllm/streaming.py,sha256=i_FU_Mt-3F2lBEImYav8I5pEjUSKYk3JFIW3lkiXEb8,8813
-fastllm/types.py,sha256=q4rZHTD9sghHI8j5cNQRWmrQW_NO8zYa0KEibKGiSyI,19603
-python_fastllm-0.0.53.dist-info/METADATA,sha256=5mJQJPAsu4tKE4Icowyjc1HaZCEE8xNRH7F1kUJVkKY,18537
-python_fastllm-0.0.53.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_fastllm-0.0.53.dist-info/entry_points.txt,sha256=WkWd04F3xVYFP5bsexaQe9Se6uelwE5ULoTtHWreO0s,133
-python_fastllm-0.0.53.dist-info/top_level.txt,sha256=F8qodL7nEGUHGmzzqfhNKCTIr1i0D6cvudOnm3z7o0Y,8
-python_fastllm-0.0.53.dist-info/RECORD,,