chinf 0.0.1__tar.gz

chinf-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexander Fedotov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chinf-0.0.1/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: chinf
+Version: 0.0.1
+Summary: Package description
+Author-email: Machina Ratiocinatrix <machina.ratio@gmail.com>, Alexander Fedotov <alex.fedotov@aol.com>
+Project-URL: Homepage, https://github.com/alxfed/chinf
+Keywords: chinf
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml==6.0.3
+Dynamic: license-file
+
+# Chinf
+API calls to Cheap Inference without dependencies.
+<pre>
+  pip install chinf
+</pre>
+Then:
+```Python
+# Python
+from yaml import safe_load as yl
+from chinf.chat import chat_complete as cc
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   32000
+  stop_sequences:
+    - STOP
+    - "\nTitle"
+  temperature:  1.0
+  top_k:        10
+  top_p:        0.5
+  reasoning_effort: high
+"""
+
+instruction = 'You are a helpful assistant. Do not use markdown or lists in your responses.'
+
+weather_tool = """ # YAML definition of a function (old format)
+  type: function
+  function:
+    name: get_weather
+    description: Determine weather in a location
+    parameters:
+      type: object
+      properties:
+        location:
+          type: string
+          description: The city and state, e.g. San Francisco, CA
+      additionalProperties: false
+      required:
+        - location
+"""
+
+tools = [yl(weather_tool)]
+
+msgs = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+thoughts, text = cc(
+    messages=msgs,
+    instructions=instruction,
+    tools=tools,
+    **yl(kwargs)
+)
+```
+or
+```Python
+from yaml import safe_load as yl
+from chinf.messages import message
+
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   32000
+  stop_sequences:
+    - STOP
+    - "\nTitle"
+  temperature:  1.0
+  top_k:        10
+  top_p:        0.5
+  thinking:     
+    type: enabled
+    budget_tokens: 24576
+    display: summarized
+  tool_choice:
+    type: auto
+    disable_parallel_tool_use: false
+"""
+
+instruction = 'You are a helpful assistant. Do not use markdown or lists in your responses.'
+
+get_weather_tool_str = """ # YAML definition of a function
+    name: get_weather
+    description: Determine weather in a location
+    input_schema:
+      type: object
+      properties:
+        location:
+          type: string
+          description: The city and state, e.g. San Francisco, CA
+      additionalProperties: true
+      required:
+        - location
+    """
+
+tools = [yl(get_weather_tool_str)]
+
+msg = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+thoughts, text = message(
+    messages=msg,
+    instructions=instruction,
+    tools=tools,
+    **yl(kwargs)
+)
+```
+or
+
+```Python
+from yaml import safe_load as yl
+from chinf.responses import respond
+
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   64000
+  temperature:  1.0
+"""
+
+msgs = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+weather_tool = """ # YAML definition of a function (new format)
+  type: function
+  name: get_weather
+  description: Determine weather in a location
+  parameters:
+    type: object
+    properties:
+      location:
+        type: string
+        description: The city and state, e.g. San Francisco, CA
+    additionalProperties: false
+    required:
+      - location
+"""
+
+tools = [yl(weather_tool)]
+
+instructions = """
+You are a helpful assistant.
+Rubric: respond in plain text without any markdown, emphasis or lists;
+all paragraphs except the first one should begin with a newline and a tab.
+"""
+
+thougts, text = respond(
+    messages=msgs,
+    instructions=instructions,
+    tools=tools,
+    **yl(kwargs)
+)
+```

chinf-0.0.1/README.md

@@ -0,0 +1,145 @@
+# Chinf
+API calls to Cheap Inference without dependencies.
+<pre>
+  pip install chinf
+</pre>
+Then:
+```Python
+# Python
+from yaml import safe_load as yl
+from chinf.chat import chat_complete as cc
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   32000
+  stop_sequences:
+    - STOP
+    - "\nTitle"
+  temperature:  1.0
+  top_k:        10
+  top_p:        0.5
+  reasoning_effort: high
+"""
+
+instruction = 'You are a helpful assistant. Do not use markdown or lists in your responses.'
+
+weather_tool = """ # YAML definition of a function (old format)
+  type: function
+  function:
+    name: get_weather
+    description: Determine weather in a location
+    parameters:
+      type: object
+      properties:
+        location:
+          type: string
+          description: The city and state, e.g. San Francisco, CA
+      additionalProperties: false
+      required:
+        - location
+"""
+
+tools = [yl(weather_tool)]
+
+msgs = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+thoughts, text = cc(
+    messages=msgs,
+    instructions=instruction,
+    tools=tools,
+    **yl(kwargs)
+)
+```
+or
+```Python
+from yaml import safe_load as yl
+from chinf.messages import message
+
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   32000
+  stop_sequences:
+    - STOP
+    - "\nTitle"
+  temperature:  1.0
+  top_k:        10
+  top_p:        0.5
+  thinking:     
+    type: enabled
+    budget_tokens: 24576
+    display: summarized
+  tool_choice:
+    type: auto
+    disable_parallel_tool_use: false
+"""
+
+instruction = 'You are a helpful assistant. Do not use markdown or lists in your responses.'
+
+get_weather_tool_str = """ # YAML definition of a function
+    name: get_weather
+    description: Determine weather in a location
+    input_schema:
+      type: object
+      properties:
+        location:
+          type: string
+          description: The city and state, e.g. San Francisco, CA
+      additionalProperties: true
+      required:
+        - location
+    """
+
+tools = [yl(get_weather_tool_str)]
+
+msg = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+thoughts, text = message(
+    messages=msg,
+    instructions=instruction,
+    tools=tools,
+    **yl(kwargs)
+)
+```
+or
+
+```Python
+from yaml import safe_load as yl
+from chinf.responses import respond
+
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   64000
+  temperature:  1.0
+"""
+
+msgs = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+weather_tool = """ # YAML definition of a function (new format)
+  type: function
+  name: get_weather
+  description: Determine weather in a location
+  parameters:
+    type: object
+    properties:
+      location:
+        type: string
+        description: The city and state, e.g. San Francisco, CA
+    additionalProperties: false
+    required:
+      - location
+"""
+
+tools = [yl(weather_tool)]
+
+instructions = """
+You are a helpful assistant.
+Rubric: respond in plain text without any markdown, emphasis or lists;
+all paragraphs except the first one should begin with a newline and a tab.
+"""
+
+thougts, text = respond(
+    messages=msgs,
+    instructions=instructions,
+    tools=tools,
+    **yl(kwargs)
+)
+```

chinf-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=67.0"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "chinf"
+version = "0.0.1"
+authors = [
+    {name="Machina Ratiocinatrix", email="machina.ratio@gmail.com"},
+    {name="Alexander Fedotov", email="alex.fedotov@aol.com"}
+]
+description = "Package description"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+]
+
+keywords = ["chinf"]
+
+dependencies = [
+    "pyyaml == 6.0.3"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/alxfed/chinf"

chinf-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chinf-0.0.1/src/chinf/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from .utils import (query,
+                    headers,
+                    get_function,
+                    get_func_args,
+                    call_function,
+                    decode_output,
+                    default_model)
+from .chat import chat_complete
+from .completion import complete
+from .responses import respond
+from .messages import message
+
+__all__ = [
+    "chat_complete",
+    "complete",
+    "respond",
+    "message",
+    # The API calling
+    "query",
+    "headers",
+    # and all the function calling stuff
+    "get_function",
+    "get_func_args",
+    "call_function",
+    "decode_output",
+    "default_model"
+]

chinf-0.0.1/src/chinf/chat.py

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+import json
+from os import environ
+from .utils import (query,
+                    default_model,
+                    get_function,
+                    get_func_args,
+                    call_function)
+
+
+def get_weather(location):
+    print(f"Executing weather tool for location: {location}")
+    return {"temperature": "72F", "condition": "Sunny"}
+#
+#
+# def query(payload):
+#     # Convert data dictionary to JSON and encode it to bytes
+#     data_bytes = json.dumps(payload).encode('utf-8')
+#     # Create the Request object
+#     req = urllib.request.Request(
+#         f'{api_base}/chat/completions',
+#         data=data_bytes,
+#         headers=headers,
+#         method="POST")
+#     # Try to query
+#     try:
+#         # Execute the request
+#         with urllib.request.urlopen(req, timeout=3000) as response:
+#             response_data = response.read().decode('utf-8')
+#             output = json.loads(response_data)
+#         return output
+#
+#     except urllib.error.HTTPError as e:
+#         # Handle HTTP errors (e.g., 401 Unauthorized, 400 Bad Request)
+#         error_info = e.read().decode('utf-8', errors='ignore')
+#         print(f"HTTP Error {e.code}: {e.reason}")
+#         print(f"Error Details: {error_info}")
+#         return {}
+#
+#     except urllib.error.URLError as e:
+#         # Handle network/connection errors
+#         print(f"Failed to reach the server: {e.reason}")
+#         return {}
+
+
+def chat_complete(messages=None, instructions=None, tools=None, **kwargs):
+    """ All parameters should be in kwargs, but they are optional
+    """
+    # Receive the instruction
+    instruction = kwargs.get('system_instruction', instructions)
+    first_message = [dict(role='system', content=instruction)] if instruction else []
+
+    # add contents and user text to the first (instruction) message
+    first_message.extend(messages)
+    instruction_and_contents = first_message
+
+    # Define the initial payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "messages":         instruction_and_contents,
+        "max_tokens":       kwargs.get("max_tokens", 132000),
+        "reasoning_effort": "max",
+    }
+    # Tools if there are some
+    if tools:
+        payload['tools'] = tools
+        payload['tool_choice'] = 'auto'
+
+    while True:
+        # Query the API
+        result = query(payload, '/chat/completions')
+        message = result['choices'][0]['message']
+        instruction_and_contents.append(message)
+        thoughts = message['reasoning_content']
+        text = message['content']
+        function_calls = message.get('tool_calls', [])
+
+        if function_calls:
+            for function_call in function_calls:
+                call_id = function_call.get('id')
+                func = function_call.get('function')
+                func_name = func.get('name')
+                func_args_str = func.get('arguments', '{}')
+
+                try:
+                    if isinstance(func_args_str, str):
+                        func_args = json.loads(func_args_str)
+                    else:
+                        func_args = func_args_str
+                except Exception as e:
+                    func_args = {}
+                    print(f"Error parsing tool arguments for {func_name}: {e}")
+
+                # Look up tool by name in globals and caller frames
+                func = globals().get(func_name)
+                # if not func:
+                #     import inspect
+                #     frame = inspect.currentframe().f_back
+                #     while frame:
+                #         if func_name in frame.f_globals:
+                #             func = frame.f_globals[func_name]
+                #             break
+                #         frame = frame.f_back
+
+                if func and callable(func):
+                    try:
+                        tool_result = func(**func_args)
+                        if isinstance(tool_result, (dict, list)):
+                            result = json.dumps(tool_result)
+                        else:
+                            result = str(tool_result)
+                    except Exception as e:
+                        result = f"Error executing tool {func_name}: {str(e)}"
+                        print(result)
+                else:
+                    result = f"Error: Tool function {func_name} not found."
+                    print(result)
+
+                tool_message = {
+                    "role": "tool",
+                    "tool_call_id": call_id,
+                    "content": result
+                }
+                # Add the response
+                instruction_and_contents.append(tool_message)
+        else:
+            break
+    return thoughts, text
+
+
+if __name__ == "__main__":
+
+    def get_weather(location):
+        print(f"Executing weather tool for location: {location}")
+        return {"temperature": "72F", "condition": "Sunny"}
+
+    get_weather_tool = {
+      "type": "function",
+      "function": {
+          "name": "get_weather",
+          "description": "Determine weather in my location",
+          "parameters": {
+              "type": "object",
+              "properties": {
+                  "location": {
+                      "type": "string",
+                      "description": "The city and state, e.g. San Francisco, CA"
+                  },
+              },
+              "additionalProperties": False,
+              "required": [
+                  "location"
+              ]
+          }
+      }
+    }
+
+    tools = [get_weather_tool]
+    messages = [
+        {"role": "user", "content": "Compare the weather in Oakland, CA and weather in Paris, France. Use the tool for learning both."}
+    ]
+    instructions = "You are a helpful assistant with tools."
+
+    thought, txt = respond(messages, instructions, tools)
+    print(thought, txt)
+    ...
+    """
+    {
+      "type": "function",
+      "function": {
+        "name": "submit_arbitrary_data",
+        "description": "CRITICAL: You must invent and generate all keys for this payload based on the context. Do not send an empty object. Every key you create must map to a string value.",
+        "strict": false,
+        "parameters": {
+          "type": "object",
+          "properties": {},
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      }
+    }
+    
+    Payload Rule: When executing the submit_arbitrary_data tool, you must dynamically generate the entire payload structure yourself. Analyze the user's input, extract all relevant variables, invent descriptive key names for them, and assign them values. Every single value must be a string.
+    """

chinf-0.0.1/src/chinf/completion.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from .utils import (default_model,
+                    query)
+
+
+def complete(text, **kwargs):
+    """A completions endpoint call through requests.
+        kwargs:
+            temperature     = 0 to 1.0
+            top_p           = 0.0 to 1.0
+            n               = 1 to 128
+            best_of         = 4
+            frequency_penalty = -2.0 to 2.0
+            presence_penalty = -2.0 to 2.0
+            max_tokens      = number of tokens
+            logprobs        = number up to 5
+            stop            = ["stop"]  array of up to 4 sequences
+            logit_bias      = map token: bias -1.0 to 1.0 (restrictive -100 to 100)
+    """
+    responses = []
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "prompt":           kwargs.get("prompt", text),
+        "response_format":  kwargs.get('response_format', {'type': 'text'}),
+        "reasoning_effort": kwargs.get("reasoning_effort", "high"),
+        "reasoning_history":kwargs.get("reasoning_history", "interleaved"),
+        "thinking":         kwargs.get("thinking", None),
+        "max_tokens":       kwargs.get("max_tokens", 5),
+        "n":                kwargs.get("n", 1),
+        "stop":             kwargs.get("stop_sequences", ["stop"]),
+        # "seed":             kwargs.get("seed", None),
+        "frequency_penalty":kwargs.get("frequency_penalty", 0),
+        "presence_penalty": kwargs.get("presence_penalty", 0),
+        # "logit_bias":       kwargs.get("logit_bias", None),
+        "logprobs":         kwargs.get("logprobs", None),
+        # "top_logprobs":     kwargs.get("top_logprobs", None),
+        "temperature":      kwargs.get("temperature", 1),
+        "top_p":            kwargs.get("top_p", 1),
+        'top_k':            kwargs.get('top_k', 50),
+        'stream':           False,
+        # "user":             kwargs.get("user", None)
+    }
+
+    responses = query(payload, '/completions')
+    response = responses['choices'][0]
+    text = response['text']
+    thoughts = ''
+
+    return thoughts, text
+
+
+if __name__ == '__main__':
+    ...

chinf-0.0.1/src/chinf/messages.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from .utils import (query,
+                    decode,
+                    default_model,
+                    get_function,
+                    get_func_args,
+                    call_function)
+
+
+def get_weather(location):
+    # print(f"Executing weather tool for location: {location}")
+    return {"temperature": "72F", "condition": "Sunny"}
+
+
+def message(messages=None, instructions=None, tools=None, **kwargs):
+    """A continuation of text with a given context and instruction.
+        kwargs:
+            temperature     = 0 to 1.0
+            top_p           = 0.0 to 1.0
+            top_k           = The maximum number of tokens to consider when sampling.
+            n               = 1 to ...
+            max_tokens      = number of tokens
+            stop            = ['stop']  array of up to 4 sequences
+    """
+    # instruction         = kwargs.get('system_instruction', instructions)
+    # first_message       = [dict(role='system', content=instruction)] if instruction else []
+
+    # contents can come in kwards or as an argument
+    messages            = kwargs.get('messages', messages)
+
+    # add contents and user text to the first (instruction) message
+    # first_message.extend(messages)
+    # instruction_and_contents = first_message
+
+    payload = {
+        'model':                    kwargs.get('model', default_model),
+        'system':                   kwargs.get('system', instructions),
+        'messages':                 kwargs.get('messages', messages),
+        'output_config':            kwargs.get('output_config',{'effort': 'high'}),
+        'thinking':                 kwargs.get('thinking', {
+                                                            'type': 'enabled',
+                                                            'budget_tokens': 10000,
+                                                            }),
+        'tool_choice':              kwargs.get('tool_choice', {'type': 'auto', 'disable_parallel_tool_use': False}),
+        'max_tokens':               kwargs.get('max_tokens', 4096),
+        'prompt_truncate_len':      kwargs.get('prompt_truncate_len', 100000),
+        'n':                        kwargs.get('n', 1),
+        'top_p':                    kwargs.get('top_p', 0.9),
+        'top_k':                    kwargs.get('top_k', 10),
+        'stream':                   False
+    }
+    if tools:
+        payload['tools'] = tools
+        payload['parallel_tool_calls'] = True
+        payload['tool_choice'] = 'auto'
+
+    while True:
+        result = query(payload, '/messages')
+        completion_message = result['content']
+        thoughts, text, function_calls = decode(completion_message)
+        if function_calls:
+            payload['messages'].append({"role": "assistant", "content": completion_message})
+            tools_results = []
+            # Call all requested functions and create response messages.
+            for function_call in function_calls:
+                call_id = function_call.get('id')
+                func_name = function_call.get('name', '')
+                func_args_def = function_call.get('input', '{}')
+                # Look up tool by name in globals and caller frames
+                func = get_function(func_name)
+                func_args = get_func_args(func_args_def)
+                result = call_function(func, func_args)
+                tool_message = {
+                    "type": "tool_result",
+                    "tool_use_id": call_id,
+                    "content": result
+                }
+                tools_results.append(tool_message)
+
+            # Add results to payload and make a query.
+            payload['messages'].append({"role": "user", "content": tools_results})
+
+        else:
+            break
+
+    return thoughts, text
+
+
+if __name__ == '__main__':
+    ...

chinf-0.0.1/src/chinf/resp_simplified.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from .utils import (query,
+                    default_model,
+                    decode_output)
+
+
+def respond(messages=None, instructions=None, **kwargs):
+    """ All parameters should be in kwargs, but they are optional
+    """
+    # Receive the instruction
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the initial payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "instructions":     instruction,
+        "input":            messages,
+        "previous_response_id": kwargs.get("previous_response_id", None),
+        "max_output_tokens": kwargs.get("max_tokens", 132000),
+        "prompt_cache_retention": "in_memory",
+        "include": ["reasoning.encrypted_content"],
+        "reasoning": {
+            "effort": "high",
+            "summary": "detailed"
+        }
+    }
+    # Query the API
+    result = query(payload, '/responses')
+    thoughts, text, _ = decode_output(result.get('output', {}))
+
+    return thoughts, text
+
+
+if __name__ == "__main__":
+    ...

chinf-0.0.1/src/chinf/responses.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from .utils import (query,
+                    default_model,
+                    get_function,
+                    get_func_args,
+                    call_function,
+                    decode_output)
+
+
+def get_weather(location):
+    # print(f"Executing weather tool for location: {location}")
+    return {"temperature": "72F", "condition": "Sunny"}
+
+
+def respond(messages=None, instructions=None, tools=None, **kwargs):
+    """ All parameters should be in kwargs, but they are optional
+    """
+    # Receive the instruction
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the initial payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "instructions":     instruction,
+        "input":            messages,
+        "previous_response_id": kwargs.get("previous_response_id", None),
+        "max_output_tokens": kwargs.get("max_tokens", 132000),
+        "prompt_cache_retention": "in_memory",
+        "include": ["reasoning.encrypted_content"],
+        "reasoning": {
+            "effort": "high",
+            "summary": "detailed"
+        }
+    }
+    # Tools if there are some
+    if tools:
+        payload['tools'] = tools
+        payload['parallel_tool_calls'] = True
+        payload['max_tool_calls'] = kwargs.get("max_tool_calls", None)
+        payload['tool_choice'] = 'auto'
+
+    while True:
+        # Query the API
+        result = query(payload, '/responses')
+        # id of the response
+        response_id = result['id']
+        thoughts, text, function_calls = decode_output(result.get('output', {}))
+
+        if function_calls:
+            function_outputs_messages = []
+            for function_call in function_calls:
+                call_id = function_call.get('call_id')
+                func_name = function_call.get('name')
+                func_args_str = function_call.get('arguments', {})
+
+                # Look up tool by name in globals and in caller frames
+                func = get_function(func_name)
+                func_args = get_func_args(func_args_str)
+                result = call_function(func, func_args)
+
+                tool_message = {
+                    "type": "function_call_output",
+                    "call_id": call_id,
+                    "output": result
+                }
+                function_outputs_messages.append(tool_message)
+
+            # Now that all responses have been gathered
+            # we can change the payload and send them back
+            payload['previous_response_id'] = response_id
+            payload['input'] = function_outputs_messages
+        else:
+            break
+
+    return thoughts, text
+
+
+if __name__ == "__main__":
+    ...

chinf-0.0.1/src/chinf/utils.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+import json
+import urllib.request
+import urllib.error
+from os import environ
+
+
+# The configuration.
+api_key = environ.get("CHINF_API_KEY", '')
+default_model = environ.get("CHINF_DEFAULT_MODEL", 'gpt-5.6-luna')
+api_base = environ.get("CHINF_API_BASE", "https://api.cheaperinference.com/v1")
+
+# Set the mandatory headers
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {api_key}",
+    "User-Agent": "chinf"
+}
+
+
+def get_function(func_name):
+    # Look up tool by name in globals
+    func = globals().get(func_name)
+    # Look up in the caller frames
+    if not func:
+        import inspect
+        frame = inspect.currentframe().f_back
+        while frame:
+            if func_name in frame.f_globals:
+                func = frame.f_globals[func_name]
+                break
+            frame = frame.f_back
+
+    return func
+
+
+def get_func_args(func_args_str):
+    try:
+        if isinstance(func_args_str, str):
+            func_args = json.loads(func_args_str)
+        else:
+            func_args = func_args_str
+    except Exception as e:
+        func_args = {}
+        print(f"Error parsing tool arguments: {e}")
+
+    return func_args
+
+
+def call_function(func, func_args):
+    if func and callable(func):
+        try:
+            tool_result = func(**func_args)
+            if isinstance(tool_result, (dict, list)):
+                result = json.dumps(tool_result)
+            else:
+                result = str(tool_result)
+        except Exception as e:
+            result = f"Error executing tool: {str(e)}"
+            print(result)
+    else:
+        result = f"Error: Tool function not callable."
+        print(result)
+
+    return result
+
+
+def query(payload, url_suffix):
+    # Convert data dictionary to JSON and encode it to bytes
+    data_bytes = json.dumps(payload).encode('utf-8')
+    # Create the Request object
+    req = urllib.request.Request(
+        f'{api_base}{url_suffix}',
+        data=data_bytes,
+        headers=headers,
+        method="POST")
+    # Try to query
+    try:
+        # Execute the request
+        with urllib.request.urlopen(req, timeout=3000) as response:
+            response_data = response.read().decode('utf-8')
+            output = json.loads(response_data)
+        return output
+
+    except urllib.error.HTTPError as e:
+        # Handle HTTP errors (e.g., 401 Unauthorized, 400 Bad Request)
+        error_info = e.read().decode('utf-8', errors='ignore')
+        print(f"HTTP Error {e.code}: {e.reason}")
+        print(f"Error Details: {error_info}")
+        return {}
+
+    except urllib.error.URLError as e:
+        # Handle network/connection errors
+        print(f"Failed to reach the server: {e.reason}")
+        return {}
+
+
+def decode_output(output):
+    # Parse the result
+    text = ''; thoughts = ''
+    for part in output:
+        part_type = part.get('type', None)
+        if part_type == 'message':
+            text = " ".join([chunk['text'] for chunk in part['content'] if chunk['type'] == 'output_text'])
+        elif part_type == 'reasoning':
+            thoughts = " ".join([chunk['text'] for chunk in part['summary'] if chunk['type'] == 'summary_text'])
+    function_calls = [part for part in output if part['type'] == 'function_call']
+    return thoughts, text, function_calls
+
+
+def decode(output):
+    text = ''
+    thoughts = ''
+    for chunk in output:
+        chunk_type = chunk.get('type', '')
+        if chunk_type == 'text':
+            addition = chunk.get('text', '')
+            if addition not in ('\n\n', '\n'):
+                text += addition
+
+        elif chunk_type == 'thinking':
+            thoughts += chunk.get('thinking', '')
+    function_calls = [part for part in output if part['type'] == 'tool_use']
+
+    return thoughts, text, function_calls

chinf-0.0.1/src/chinf.egg-info/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: chinf
+Version: 0.0.1
+Summary: Package description
+Author-email: Machina Ratiocinatrix <machina.ratio@gmail.com>, Alexander Fedotov <alex.fedotov@aol.com>
+Project-URL: Homepage, https://github.com/alxfed/chinf
+Keywords: chinf
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml==6.0.3
+Dynamic: license-file
+
+# Chinf
+API calls to Cheap Inference without dependencies.
+<pre>
+  pip install chinf
+</pre>
+Then:
+```Python
+# Python
+from yaml import safe_load as yl
+from chinf.chat import chat_complete as cc
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   32000
+  stop_sequences:
+    - STOP
+    - "\nTitle"
+  temperature:  1.0
+  top_k:        10
+  top_p:        0.5
+  reasoning_effort: high
+"""
+
+instruction = 'You are a helpful assistant. Do not use markdown or lists in your responses.'
+
+weather_tool = """ # YAML definition of a function (old format)
+  type: function
+  function:
+    name: get_weather
+    description: Determine weather in a location
+    parameters:
+      type: object
+      properties:
+        location:
+          type: string
+          description: The city and state, e.g. San Francisco, CA
+      additionalProperties: false
+      required:
+        - location
+"""
+
+tools = [yl(weather_tool)]
+
+msgs = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+thoughts, text = cc(
+    messages=msgs,
+    instructions=instruction,
+    tools=tools,
+    **yl(kwargs)
+)
+```
+or
+```Python
+from yaml import safe_load as yl
+from chinf.messages import message
+
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   32000
+  stop_sequences:
+    - STOP
+    - "\nTitle"
+  temperature:  1.0
+  top_k:        10
+  top_p:        0.5
+  thinking:     
+    type: enabled
+    budget_tokens: 24576
+    display: summarized
+  tool_choice:
+    type: auto
+    disable_parallel_tool_use: false
+"""
+
+instruction = 'You are a helpful assistant. Do not use markdown or lists in your responses.'
+
+get_weather_tool_str = """ # YAML definition of a function
+    name: get_weather
+    description: Determine weather in a location
+    input_schema:
+      type: object
+      properties:
+        location:
+          type: string
+          description: The city and state, e.g. San Francisco, CA
+      additionalProperties: true
+      required:
+        - location
+    """
+
+tools = [yl(get_weather_tool_str)]
+
+msg = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+thoughts, text = message(
+    messages=msg,
+    instructions=instruction,
+    tools=tools,
+    **yl(kwargs)
+)
+```
+or
+
+```Python
+from yaml import safe_load as yl
+from chinf.responses import respond
+
+
+kwargs = """  # this is a string in YAML format
+  max_tokens:   64000
+  temperature:  1.0
+"""
+
+msgs = [{'role': 'user', 'content': 'What is the weather in Chicago, IL and Paris, France?'}]
+
+weather_tool = """ # YAML definition of a function (new format)
+  type: function
+  name: get_weather
+  description: Determine weather in a location
+  parameters:
+    type: object
+    properties:
+      location:
+        type: string
+        description: The city and state, e.g. San Francisco, CA
+    additionalProperties: false
+    required:
+      - location
+"""
+
+tools = [yl(weather_tool)]
+
+instructions = """
+You are a helpful assistant.
+Rubric: respond in plain text without any markdown, emphasis or lists;
+all paragraphs except the first one should begin with a newline and a tab.
+"""
+
+thougts, text = respond(
+    messages=msgs,
+    instructions=instructions,
+    tools=tools,
+    **yl(kwargs)
+)
+```

chinf-0.0.1/src/chinf.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/chinf/__init__.py
+src/chinf/chat.py
+src/chinf/completion.py
+src/chinf/messages.py
+src/chinf/resp_simplified.py
+src/chinf/responses.py
+src/chinf/utils.py
+src/chinf.egg-info/PKG-INFO
+src/chinf.egg-info/SOURCES.txt
+src/chinf.egg-info/dependency_links.txt
+src/chinf.egg-info/requires.txt
+src/chinf.egg-info/top_level.txt

chinf-0.0.1/src/chinf.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chinf-0.0.1/src/chinf.egg-info/requires.txt

@@ -0,0 +1 @@
+pyyaml==6.0.3

chinf-0.0.1/src/chinf.egg-info/top_level.txt

@@ -0,0 +1 @@
+chinf