python-fastllm 0.0.1__py3-none-any.whl

fastllm/openai_responses.py

@@ -0,0 +1,260 @@
+# 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', 'norm_sse_event',
+           'delta_index_fn', '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_file', 'denorm_tool_result', 'mk_payload', 'get_hdrs', 'cost']
+
+# %% ../nbs/02_oai_responses.ipynb #591f55b5
+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/02_oai_responses.ipynb #479243ae
+def norm_tool_call(item):
+    typ = item.get("type", "")
+    if typ == "function_call":
+        extra = {k:v for k,v in item.items() if k not in ("id","name","arguments")}
+        return ToolCall(id=item["id"], name=item["name"], arguments=json.loads(item["arguments"]), extra=extra)
+    if typ.endswith("_call"):  # web_search_call, file_search_call, etc.
+        name = typ.removesuffix("_call")
+        extra = {k:v for k,v in item.items() if k not in ("id")}
+        return ToolCall(id=item.get("id",""), name=name, arguments=item.get("action", {}), server=True, extra=extra)
+
+def norm_tool_calls(resp):
+    "Extract Responses API tool call items as normalized tool calls."
+    out = []
+    for item in resp.get('output', []):
+        if tc := norm_tool_call(item): out.append(tc)
+    return out
+
+# %% ../nbs/02_oai_responses.ipynb #a199aab4
+def norm_usage(resp):
+    "Normalize OpenAI usage shape(s)."
+    if not (usg:=resp.get("usage")): return None
+    pt = int(usg.get("prompt_tokens", usg.get("input_tokens", 0)) or 0)
+    ct = int(usg.get("completion_tokens", usg.get("output_tokens", 0)) or 0)
+    tt = int(usg.get("total_tokens", pt + ct) or (pt + ct))
+    pd = usg.get("prompt_tokens_details") or usg.get("input_tokens_details") or {}
+    cd = usg.get("completion_tokens_details") or usg.get("output_tokens_details") or {}
+    cached = int(pd.get("cached_tokens", 0) or 0)
+    reasoning = int(cd.get("reasoning_tokens", 0) or 0)
+    server_tool_use = dict(Counter(o['type'] for o in resp.get('output', []) if o.get('type') != 'function_call' and o.get('type', '').endswith('_call')))
+    if server_tool_use: usg['server_tool_use'] = server_tool_use
+    return Usage(prompt_tokens=pt, completion_tokens=ct, total_tokens=tt,
+                 cached_tokens=cached, reasoning_tokens=reasoning, raw=usg)
+
+
+# %% ../nbs/02_oai_responses.ipynb #95102df4
+def norm_finish(resp, tcs=None):
+    "Canonicalize finish_reason to OpenAI Chat values: stop, tool_calls, length, content_filter."
+    reason = resp.get("status")
+    mp = dict(completed=FinishReason.stop, incomplete=FinishReason.length, failed=FinishReason.content_filter)
+    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 #4ef27720
+def norm_parts(resp):
+    parts = []
+    for item in resp["output"]:
+        if (typ:=item["type"]) == "message":
+            for c in item["content"]:
+                if (ctyp := c["type"]) == "output_text":
+                    c['citations'] = c.pop('annotations', [])
+                    parts.append(Part(type=PartType.text, text=c['text'], data=c))
+                elif ctyp == "refusal":
+                    parts.append(Part(type=PartType.refusal, text=c['refusal'], data=c))
+        elif typ == "reasoning":
+            for s in item["summary"]: parts.append(Part(type=PartType.thinking, text=s['text'], data=item))
+        elif typ == "function_call" or typ.endswith("_call"):
+            tc = norm_tool_call(item)
+            tdata = {**tc.extra, 'id':tc.id, 'name':tc.name, 'arguments':tc.arguments, 'server':tc.server}
+            parts.append(Part(type=PartType.tool_use, data=tdata))
+    return parts
+
+# %% ../nbs/02_oai_responses.ipynb #7cd48aa5
+def norm_sse_event(ev, **kwargs):
+    "Normalize OpenAI Responses API stream event into Delta."
+    typ = ev.get("type")
+    if typ == "response.output_text.delta":            return Delta(text=ev.get("delta"), raw=ev, **kwargs)
+    if typ == "response.reasoning_text.delta":         return Delta(thinking=ev.get("delta",""), raw=ev, **kwargs)
+    if typ == "response.reasoning_summary_text.delta": return Delta(thinking=ev.get("delta",""), raw=ev, **kwargs)
+    if typ == "response.output_text.annotation.added": return Delta(citations=[ev.get("annotation")], raw=ev, **kwargs)
+    if typ == "response.output_item.done":
+        item = ev.get("item", {})
+        itype = item.get("type", "")
+        if itype == "function_call" or itype.endswith("_call"):
+            return Delta(tool_calls=[norm_tool_call(item)], raw=ev, **kwargs)
+    if typ in ("response.completed", "response.incomplete"):
+        resp = ev.get("response", {})
+        return Delta(finish_reason=norm_finish(resp), usage=norm_usage(resp), raw=ev, **kwargs)
+    if typ == "error": raise api_error_from_event(ev)
+
+# %% ../nbs/02_oai_responses.ipynb #66370799
+def delta_index_fn(d, typ, last_typ, last_idx):
+    'Returns accumulation index for current delta and updated last idx'
+    idx = nested_idx(d, 'raw', 'output_index')
+    return idx, idx
+
+# %% ../nbs/02_oai_responses.ipynb #021b5257
+@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
+
+# %% ../nbs/02_oai_responses.ipynb #b746c82b
+def denorm_tool_use(p:Part):
+    "Convert canonical tool_use Part back to OpenAI Responses function_call item."
+    return dict(type='function_call', call_id=p.data.get('id'), name=p.data.get('name'), arguments=json.dumps(p.data.get('arguments', '{}')))
+
+# %% ../nbs/02_oai_responses.ipynb #8f42adf7
+def denorm_tool(m:Msg):
+    items = []
+    for part in m.content:
+        if part.type == PartType.tool_result: items.append(denorm_tool_result(part))
+    return items
+
+# %% ../nbs/02_oai_responses.ipynb #67c8de13
+def denorm_assistant(m:Msg):
+    items, srv_call_id = [], None
+    for p in m.content:
+        if p.type == PartType.tool_use:
+            items.append(denorm_tool_use(p))
+            # TODO: Server tcs are excluded during deserialization in lisette, so this
+            # is not used. Anthropic checks for `srvtoolu` and requires the full tool result metadata
+            # which is a lot to store.
+            # Instead of reconstructing server tool calls as actual tool uses we can make it a regular msg
+            # telling AI a server tool was executed
+            if p.data.get('server'):
+                srv_txt = f"[Server tool `{p.data['name']}` executed successfully, results are generated below]"
+                items.append(dict(type='function_call_output', call_id=p.data['id'], output=srv_txt))    
+        elif p.type in (PartType.text, PartType.thinking):
+            items.append(dict(type="message", role="assistant", content=[dict(type="output_text", text=p.text)]))
+    return items
+
+# %% ../nbs/02_oai_responses.ipynb #64883b99
+def denorm_msgs(msgs:list[Msg]):
+    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/02_oai_responses.ipynb #f280226d
+def denorm_tool_schs(tools):
+    "Convert canonical tools to OpenAI Responses 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(type='function', name=name, description=desc, parameters=params))
+    return out
+
+# %% ../nbs/02_oai_responses.ipynb #a6bc189c
+def denorm_tool_choice(v):
+    "Map canonical tool_choice to OpenAI Responses format."
+    _tc_modes = {'auto', 'required', 'any', 'force', 'none', 'off', 'disabled'}
+    if v is None: return None
+    if v in _tc_modes: return v if v in ('auto','none','required') else {'auto':'auto','any':'required','force':'required','off':'none','disabled':'none'}[v]
+    return {'type': 'function', 'name': v}
+
+# %% ../nbs/02_oai_responses.ipynb #b1dcf1d3
+def denorm_reasoning(v):
+    "Map canonical reasoning_effort to OpenAI Responses reasoning param."
+    if v is None: return None
+    return {'effort': v} if isinstance(v, str) else v
+
+# %% ../nbs/02_oai_responses.ipynb #e11c15c0
+def denorm_web_search(v):
+    "Map canonical web_search_options to OpenAI Responses web_search_preview tool."
+    t = {"type": "web_search_preview"}
+    if (typ := (v or {}).get("type")): t["type"] = typ
+    if (s := (v or {}).get("search_context_size")): t["search_context_size"] = s
+    if (u := (v or {}).get("user_location")): t["user_location"] = u
+    return t
+
+# %% ../nbs/02_oai_responses.ipynb #18346f93
+def denorm_system(sp): return sys_text(part_txt(sp))
+
+# %% ../nbs/02_oai_responses.ipynb #8c06da0c
+def denorm_user(m:Msg):
+    "Convert canonical user Msg to OpenAI Responses input message."
+    parts = []
+    for p in m.content:
+        if   p.type == PartType.text:        parts.append({"type": "input_text", "text": p.text or ""})
+        elif p.type == PartType.input_image: parts.append(denorm_image(p))
+        elif p.type == PartType.input_audio: raise ValueError("OpenAI Responses API does not support audio input; Coming Soon.") 
+        elif p.type == PartType.input_video: raise ValueError("OpenAI Responses API does not support video input")
+        elif p.type == PartType.input_file:  parts.append(denorm_file(p))
+    return dict(type='message', role='user', content=parts)
+
+# %% ../nbs/02_oai_responses.ipynb #4ced282f
+def denorm_image(p): return {"type": "input_image", "image_url": p.text}
+
+# %% ../nbs/02_oai_responses.ipynb #6e79a133
+def denorm_file(p):
+    if (b64:=data_url(p.text)): return {"type": "input_file", "file_data": p.text, "filename": f"upload.{b64[0].split('/')[-1]}"}
+    return {"type": "input_file", "file_url": p.text}
+
+# %% ../nbs/02_oai_responses.ipynb #145b1c79
+def denorm_tool_result(m:Part):
+    "Convert canonical tool result back to OpenAI Responses function_call_output item."
+    cid = m.data.get('id', '') or m.data.get('call_id')
+    if isinstance(m.text, list):
+        out = []
+        for p in m.text:
+            if   p.type == PartType.text:        out.append({"type": "input_text", "text": p.text or ""})
+            elif p.type == PartType.input_image: out.append(denorm_image(p))
+            elif p.type == PartType.input_file:  out.append(denorm_file(p))
+            else: raise ValueError(f"OpenAI Responses tool_result does not support {p.type}")
+        return dict(type='function_call_output', call_id=cid, output=out)
+    return dict(type='function_call_output', call_id=cid, output=str(m.text))
+
+# %% ../nbs/02_oai_responses.ipynb #9b0f81a4
+@delegates(payload_kwargs)
+def mk_payload(msgs, model, **kwargs):
+    payload = dict(model=model, input=denorm_msgs(msgs))
+    if stream:=kwargs.get('stream'):        payload['stream'] = True
+    if sp:=kwargs.get('system'):            payload['instructions'] = denorm_system(sp)
+    if mt:=kwargs.get('max_tokens'):        payload['max_output_tokens'] = mt
+    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['reasoning'] = 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/02_oai_responses.ipynb #529fd4bc
+def get_hdrs(api_key=None):
+    return {"Authorization": f"Bearer {get_api_key(api_key, 'OPENAI_API_KEY')}"}
+
+# %% ../nbs/02_oai_responses.ipynb #a907ffa8
+def cost(usage, m):
+    raw = usage.raw
+    cached = raw.get('input_tokens_details', {}).get('cached_tokens', 0)
+    in_txt = raw['input_tokens'] - cached
+    cost  = in_txt * m.input_cost_per_token + raw['output_tokens'] * m.output_cost_per_token
+    cost += cached * m.get('cache_read_input_token_cost', 0)
+    return cost
+
+# %% ../nbs/02_oai_responses.ipynb #07114b55
+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=('responses.create_response','responses.create_response'))
+api_registry.register('openai', **api_ns)