python-fastllm 0.0.1__py3-none-any.whl

fastllm/anthropic.py

@@ -0,0 +1,298 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/04_anthropic.ipynb.
+
+# %% auto #0
+__all__ = ['ant_tc_types', 'api_ns', 'norm_tool_call', 'norm_tool_calls', 'norm_usage', 'norm_finish', 'norm_parts',
+           'norm_sse_event', 'delta_index_fn', '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_file', 'denorm_tool_result', 'mk_payload',
+           'get_hdrs', 'cost']
+
+# %% ../nbs/04_anthropic.ipynb #02afd3d7
+import json
+from collections import Counter
+from fastcore.utils import *
+from fastcore.meta import *
+from fastspec.errors import api_error_from_event
+
+from .types import *
+from .streaming import *
+from .streaming import mk_acollect_stream
+
+# %% ../nbs/04_anthropic.ipynb #5656d1d6
+ant_tc_types = ("tool_use", "server_tool_use", "mcp_tool_use")
+
+def norm_tool_call(b):
+    if b.get("type") in ant_tc_types:
+        extra = {k:v for k,v in b.items() if k not in ("type","id","name","input")}
+        return ToolCall(id=b["id"], name=b["name"], arguments=b.get("input") or {}, server=b.get("type")!="tool_use", extra=extra)
+
+def norm_tool_calls(resp, delta=False):
+    "Extract Anthropic tool_use blocks as normalized tool calls."
+    out = []
+    for b in resp.get("content", []):
+        if tc:= norm_tool_call(b): out.append(tc)
+    return out
+
+# %% ../nbs/04_anthropic.ipynb #0a1e2a8e
+def norm_usage(resp):
+    "Normalize Anthropic usage shape."
+    if not (usg:=resp.get("usage")): return None
+    cached = int(usg.get("cache_read_input_tokens", 0) or 0)
+    cache_creation = int(usg.get("cache_creation_input_tokens", 0) or 0)
+    pt = int(usg.get("input_tokens", 0) or 0) + cached + cache_creation
+    ct = int(usg.get("output_tokens", 0) or 0)
+    return Usage(prompt_tokens=pt, completion_tokens=ct, total_tokens=pt + ct,
+                 cached_tokens=cached, cache_creation_tokens=cache_creation, raw=usg)
+
+# %% ../nbs/04_anthropic.ipynb #7a8b1f8f
+def norm_finish(resp, tcs=None):
+    "Canonicalize finish_reason to OpenAI Chat values: stop, tool_calls, length, content_filter."
+    reason = resp.get("stop_reason")
+    mp = dict(end_turn=FinishReason.stop, tool_use=FinishReason.tool_calls, max_tokens=FinishReason.length)
+    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 #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)
+    if typ in ant_parts_mapping: return ant_parts_mapping[typ]
+    if typ.endswith('_tool_result'): return PartType.server_tool_result
+    return typ
+
+def norm_parts(resp):
+    tcs = norm_tool_calls(resp)
+    tc_map = {tc.id: tc for tc in tcs}
+    parts = []
+    for b in resp.get("content", []):
+        typ = _ant_part_type(b.get("type", "text"))
+        if typ == PartType.thinking: parts.append(Part(type=PartType.thinking, text=b.get("thinking", ""), data=b))
+        elif typ == "tool_use":
+            if tc:=tc_map.get(b.get("id")):
+                tdata = {**tc.extra, 'id':tc.id, 'name':tc.name, 'arguments':tc.arguments, 'server':tc.server}
+                parts.append(Part(type=PartType.tool_use, data=tdata))
+        else: parts.append(Part(type=typ, text=b.get("text", ""), data=b))
+    return parts
+
+# %% ../nbs/04_anthropic.ipynb #a3869e31
+def norm_sse_event(ev, **kwargs):
+    typ = ev.get("type")
+    text, thinking, tcs, citations = None, None, [], None
+    if typ == "content_block_start":
+        cb = ev.get("content_block", {})
+        if cb.get("type", "").endswith("_tool_result"): return Delta(server_tool_result=cb, raw=ev, **kwargs)
+        if tc := norm_tool_call(cb): tcs = [tc]
+    elif typ == "content_block_delta":
+        d = ev.get("delta", {})
+        dtyp = d.get("type")
+        if   dtyp == "text_delta": text = d.get("text")
+        elif dtyp == "thinking_delta": thinking = d.get("thinking")
+        elif dtyp == "input_json_delta":
+            tcs = [ToolCall(id=str(ev.get("index", "")), name="", arguments={"_delta": d.get("partial_json", '')})]
+        elif dtyp == "citations_delta": 
+            citations = listify(d.get('citation',[]))
+    elif typ == "message_delta":
+        fin = norm_finish(ev.get('delta'))
+        return Delta(finish_reason=fin, usage=norm_usage(ev), raw=ev, **kwargs)
+    elif typ == "error": raise api_error_from_event(ev)
+    return Delta(text=text, thinking=thinking, tool_calls=tcs, citations=citations, raw=ev, **kwargs)
+
+# %% ../nbs/04_anthropic.ipynb #33cd3bd3
+def delta_index_fn(d, typ, last_typ, last_idx):
+    'Returns accumulation index for current delta and updated last idx'
+    return nested_idx(d, 'raw', 'index'), None
+
+# %% ../nbs/04_anthropic.ipynb #c994adb1
+@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='anthropic', **kwargs)
+    async for o in res: yield o
+
+# %% ../nbs/04_anthropic.ipynb #bb11ab62
+def _ant_cc(block, p):
+    "Add cache_control to block if present in Part.data."
+    if (cc := (p.data or {}).get('cache_control')): block['cache_control'] = cc
+    return block
+
+# %% ../nbs/04_anthropic.ipynb #6ec772cb
+def denorm_tool_use(p:Part):
+    "Convert canonical tool_use Part to Anthropic tool_use content block."
+    d = p.data or {}
+    block = dict(type='tool_use', id=d.get('id',''), name=d.get('name',''), input=d.get('arguments') or {})
+    if 'caller' in d: block['caller'] = d['caller']
+    return _ant_cc(block, p)
+
+def denorm_assistant(m:Msg):
+    "Convert canonical assistant Msg to Anthropic assistant message + synthetic tool results for non-Anthropic server tools."
+    blocks, srv_results, srv_call_id = [], [], None
+    for p in m.content:
+        if p.type == PartType.thinking:
+            if srv_call_id:
+                srv_results.append(dict(type='tool_result', tool_use_id=srv_call_id, content=p.text or ''))
+                srv_call_id = None
+            elif sig:=(p.data or {}).get('signature',''): blocks.append(dict(type='thinking', thinking=p.text or '', signature=sig))
+            else:                               blocks.append(_ant_cc(dict(type='text', text=p.text or ''), p))
+        elif p.type == PartType.text:
+            if srv_call_id:
+                srv_results.append(dict(type='tool_result', tool_use_id=srv_call_id, content=p.text or ''))
+                srv_call_id = None
+            else: blocks.append(_ant_cc(dict(type='text', text=p.text or ''), p))
+        elif p.type == PartType.tool_use:
+            if p.data.get('server') and (p.data.get('id','') or '').startswith('srvtoolu_'):
+                blocks.append(dict(type='server_tool_use', id=p.data['id'], name=p.data.get('name',''), input=p.data.get('arguments') or {}))
+            elif p.data.get('server'):
+                blocks.append(denorm_tool_use(p))
+                srv_call_id = p.data.get('id','')
+            else: blocks.append(denorm_tool_use(p))
+        elif p.type == PartType.server_tool_result: blocks.append(p.data if p.data else dict(type='server_tool_result'))
+    res = [dict(role='assistant', content=blocks)]
+    if srv_results: res.append(dict(role='user', content=srv_results))
+    return res
+
+def denorm_tool(m:Msg):
+    "Convert canonical tool Msg to Anthropic user message with tool_result blocks."
+    blocks = [denorm_tool_result(p) for p in m.content if p.type == PartType.tool_result]
+    return [dict(role='user', content=blocks)]
+
+def denorm_msgs(msgs:list[Msg]):
+    "Convert list of canonical Msgs to Anthropic messages."
+    res = []
+    for m in msgs:
+        if   m.role == 'user':      res.append(denorm_user(m))
+        elif m.role == 'assistant': res.extend(denorm_assistant(m))
+        elif m.role == 'tool':      res.extend(denorm_tool(m))
+    return res
+
+# %% ../nbs/04_anthropic.ipynb #f762a6f2
+def denorm_tool_schs(tools):
+    "Convert canonical tools to Anthropic format."
+    out = []
+    for t in tools:
+        fn = fn_schema(t)
+        if fn is None: out.append(t); continue
+        name, desc, params = fn
+        out.append(dict(name=name, description=desc, input_schema=params))
+    return out
+
+# %% ../nbs/04_anthropic.ipynb #6118d7ea
+def denorm_tool_choice(v):
+    "Map canonical tool_choice to Anthropic format."
+    if v is None: return None
+    if v in ('auto',):                    return {'type': 'auto'}
+    if v in ('required', 'any', 'force'): return {'type': 'any'}
+    if v in ('none', 'off', 'disabled'):  return {'type': 'none'}
+    return {'type': 'tool', 'name': v}
+
+# %% ../nbs/04_anthropic.ipynb #310f1e75
+def denorm_reasoning(v):
+    "Map canonical reasoning_effort to Anthropic adaptive thinking + output_config."
+    mp = dict(minimal='low', low='low', medium='medium', high='high', xhigh='xhigh', max='max')
+    err = ValueError(f"Invalid reasoning effort for Anthropic: {v}, accepted string values are: {list(mp)} and dicts are passthrough")
+    if v is None: return None
+    elif isinstance(v, dict): return v
+    elif isinstance(v, str) and v in mp:  return {"thinking": {"type": "adaptive"}, "output_config": {"effort": mp.get(v)}}
+    raise err
+
+# %% ../nbs/04_anthropic.ipynb #8fa9fbb8
+def denorm_web_search(v):
+    "Map canonical web_search_options to Anthropic hosted web_search tool."
+    _max_uses = {"low": 1, "medium": 5, "high": 10}
+    t = {"type": "web_search_20260209", "name": "web_search"}
+    if (typ := (v or {}).get("type")): t["type"] = typ
+    if (s := (v or {}).get("search_context_size")):
+        t["max_uses"] = _max_uses.get(s, 5)
+    if (u := (v or {}).get("user_location", {}).get("approximate")):
+        t["user_location"] = {"type": "approximate", **u}
+    return t
+
+# %% ../nbs/04_anthropic.ipynb #6b485275
+def denorm_system(sp):
+    if isinstance(sp, Msg): sp = sp.content[0]
+    if isinstance(sp, Part):
+        block = dict(type='text', text=sp.text)
+        if (cc := (sp.data or {}).get('cache_control')): block['cache_control'] = cc
+        return [block]
+    else: return sp
+
+# %% ../nbs/04_anthropic.ipynb #1b990cc9
+def denorm_user(m:Msg):
+    "Convert canonical user Msg to Anthropic user message."
+    parts = []
+    for p in m.content:
+        if   p.type == PartType.text: parts.append(_ant_cc({"type":"text", "text":p.text or ''}, p))
+        elif p.type == PartType.input_image: parts.append(_ant_cc(denorm_image(p), p))
+        elif p.type == PartType.input_audio: raise ValueError("Anthropic does not support audio input")
+        elif p.type == PartType.input_video: raise ValueError("Anthropic does not support video input")
+        elif p.type == PartType.input_file:  parts.append(_ant_cc(denorm_file(p), p))
+    return dict(role='user', content=parts)
+
+# %% ../nbs/04_anthropic.ipynb #edd87272
+def denorm_image(p):
+    if (b64:=data_url(p.text)): return {"type": "image", "source": {"type": "base64", "media_type": b64[0], "data": b64[1]}}
+    return {"type": "image", "source": {"type": "url", "url": p.text}}
+
+# %% ../nbs/04_anthropic.ipynb #fc6bbdfc
+def denorm_file(p):
+    if (b64:=data_url(p.text)): return {"type": "document", "source": {"type": "base64", "media_type": b64[0], "data": b64[1]}}
+    return {"type": "document", "source": {"type": "url", "url": p.text}}
+
+# %% ../nbs/04_anthropic.ipynb #37b63cc2
+def denorm_tool_result(p:Part):
+    "Convert canonical tool_result Part to Anthropic tool_result content block."
+    d = p.data or {}
+    tid = d.get('id') or d.get('call_id','')
+    if isinstance(p.text, list):
+        blocks = []
+        for pp in p.text:
+            if   pp.type == PartType.text:        blocks.append({"type": "text", "text": pp.text or ""})
+            elif pp.type == PartType.input_image: blocks.append(denorm_image(pp))
+            elif pp.type == PartType.input_file:  blocks.append(denorm_file(pp))
+            else: raise ValueError(f"Anthropic tool_result does not support {pp.type}")
+        return _ant_cc(dict(type='tool_result', tool_use_id=tid, content=blocks), p)
+    return _ant_cc(dict(type='tool_result', tool_use_id=tid, content=str(p.text)), p)
+
+# %% ../nbs/04_anthropic.ipynb #587d4fe5
+@delegates(payload_kwargs)
+def mk_payload(msgs, model, **kwargs):
+    payload = dict(model=model, messages=denorm_msgs(msgs), max_tokens=kwargs.get('max_tokens') or 1024)
+    if kwargs.get('stream'):                payload['stream'] = True
+    if sp:=kwargs.get('system'):            payload['system'] = denorm_system(sp)
+    if tools:=kwargs.get('tools'):          payload['tools'] = denorm_tool_schs(tools)
+    if tchc:=kwargs.get('tool_choice'):     payload['tool_choice'] = denorm_tool_choice(tchc)
+    if thk:=kwargs.get('reasoning_effort'): payload.update(denorm_reasoning(thk))
+    if (wopts:=kwargs.get('web_search_options')) is not None: 
+        payload.setdefault('tools', []).append(denorm_web_search(wopts))
+    if (temp:=kwargs.get('temperature')) is not None: 
+        payload['temperature'] = temp
+    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"}
+
+# %% ../nbs/04_anthropic.ipynb #0d03643a
+def cost(usage, m):
+    raw = usage.raw
+    in_tok = raw['input_tokens']
+    cache_read = raw.get('cache_read_input_tokens', 0)
+    cc = raw.get('cache_creation', {}) or {}
+    cache_5m  = cc.get('ephemeral_5m_input_tokens', 0)
+    cache_1h  = cc.get('ephemeral_1h_input_tokens', 0)
+    cost  = in_tok     * m.input_cost_per_token
+    cost += raw['output_tokens'] * m.output_cost_per_token
+    cost += cache_read * m.get('cache_read_input_token_cost', 0)
+    cost += cache_5m   * m.get('cache_creation_input_token_cost', 0)
+    cost += cache_1h   * m.get('cache_creation_input_token_cost_above_1hr', 0)
+    return cost
+
+# %% ../nbs/04_anthropic.ipynb #f7c0b989
+api_ns = dict(norm_tool_calls=norm_tool_calls,
+                norm_parts=norm_parts,
+                norm_finish=norm_finish,
+                norm_usage=norm_usage,
+                acollect_stream=acollect_stream,
+                mk_payload=mk_payload,
+                cost=cost,
+                get_hdrs=get_hdrs,
+                op_path=('messages.messages_post','messages.messages_post'))
+api_registry.register('anthropic', **api_ns)