thinking-machine 0.1.7__tar.gz → 0.1.9__tar.gz

{thinking_machine-0.1.7/src/thinking_machine.egg-info → thinking_machine-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thinking-machine
-Version: 0.1.7
+Version: 0.1.9
 Summary: A Machine that thinks.
 Author-email: Machina Ratiocinatrix <machina.ratio@gmail.com>, Alexander Fedotov <alex.fedotov@aol.com>
 Project-URL: Homepage, https://github.com/machina-ratiocinatrix/thinking-machine
@@ -42,15 +42,6 @@ Or:
 ```bash
 thinking-machine multilogue.txt > response.txt
 ```
-Or:
-```bash
-thinking-machine -a multilogue.txt | vim
-```
-Or:
-```bash
-thinking-machine -a multilogue.txt > tmp && echo tmp > multilogue.txt
-```
-
 Or use it in your Python code:
 ```Python
 # Python

{thinking_machine-0.1.7 → thinking_machine-0.1.9}/README.md

@@ -26,15 +26,6 @@ Or:
 ```bash
 thinking-machine multilogue.txt > response.txt
 ```
-Or:
-```bash
-thinking-machine -a multilogue.txt | vim
-```
-Or:
-```bash
-thinking-machine -a multilogue.txt > tmp && echo tmp > multilogue.txt
-```
-
 Or use it in your Python code:
 ```Python
 # Python

{thinking_machine-0.1.7 → thinking_machine-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "thinking-machine"
-version = "0.1.7"
+version = "0.1.9"
 authors = [
     {name="Machina Ratiocinatrix", email="machina.ratio@gmail.com"},
     {name="Alexander Fedotov", email="alex.fedotov@aol.com"}
@@ -24,6 +24,7 @@ dependencies = [
 
 [project.scripts]
 thinking-machine = "thinking_machine.cli:run"
+think = "thinking_machine.cli:run"
 
 [project.urls]
 "Homepage" = "https://github.com/machina-ratiocinatrix/thinking-machine"

{thinking_machine-0.1.7 → thinking_machine-0.1.9}/src/thinking_machine/cli.py

@@ -106,6 +106,10 @@ def run():
             else:
                 if config.provider == 'Baseten':
                     os.environ['BASETEN_API_KEY'] = args.provider_api_key
+                elif config.provider == 'Fireworks':
+                    os.environ['FIREWORKS_API_KEY'] = args.provider_api_key
+                elif config.provider == 'Tinker':
+                    os.environ['TINKER_API_KEY'] = args.provider_api_key
                 elif config.provider == 'Lightning':
                     os.environ['LIGHTNING_API_KEY'] = args.provider_api_key
                 else:

{thinking_machine-0.1.7 → thinking_machine-0.1.9}/src/thinking_machine/machine.py

@@ -15,7 +15,7 @@ from .utilities import (plato_text_to_muj,
 
 
 def machine(plato_text, config, **kwargs):
-    """Core agent logic.
+    """Core machine logic.
 
     1. Fetches the system prompt from a private GitHub repo.
     2. Calls Provider
@@ -49,6 +49,27 @@ def machine(plato_text, config, **kwargs):
         thoughts = llm_soup_to_text(thoughts)
         return thoughts, text
 
+    elif provider == 'Tinker':
+        # Transform plato_text to MUJ format
+        messages = plato_text_to_muj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call OpenAI API
+        environ['TINKER_API_KEY'] = api_key
+        try:
+            from .providers import tink
+        except ImportError:
+            print("openai module is missing.", file=sys.stderr)
+            sys.exit(1)
+
+        thoughts, text = tink.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        thoughts = llm_soup_to_text(thoughts)
+        return thoughts, text
+
     elif provider == 'Gemini':
         # Transform plato_text to MPUJ format
         messages = plato_text_to_mpuj(plato_text=plato_text,
@@ -212,6 +233,27 @@ def machine(plato_text, config, **kwargs):
 
         return thoughts, text
 
+    elif provider == 'Fireworks':
+        # Transform plato_text to MUJ format
+        messages = plato_text_to_muj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call OpenAI API via opehaina
+        environ['FIREWORKS_API_KEY'] = api_key
+        try:
+            from .providers import illuminati
+        except ImportError:
+            print("illuminati module is missing.", file=sys.stderr)
+            sys.exit(1)
+
+        thoughts, text = illuminati.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        thoughts = llm_soup_to_text(thoughts)
+        return thoughts, text
+
 
 if __name__ == '__main__':
     print('You have launched main')

thinking_machine-0.1.9/src/thinking_machine/providers/illuminati.py

@@ -0,0 +1,188 @@
+# -*- 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
+
+
+api_key = environ.get("TINKER_API_KEY", '')
+default_model = environ.get("TINKER_DEFAULT_MODEL", 'thinkingmachines/Inkling')
+api_base_oai = environ.get("TINKER_OAI_API_BASE", 'https://tinker.thinkingmachines.dev/services/tinker-prod/oai/api/v1')
+api_base_ant = environ.get("TINKER_ANT_API_BASE", 'https://tinker.thinkingmachines.dev/services/tinker-prod/anthropic/api/v1')
+
+
+# Set the mandatory headers
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {api_key}",
+    "User-Agent": "machine-thinking"
+}
+
+
+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_def):
+    try:
+        if isinstance(func_args_def, str):
+            func_args = json.loads(func_args_def)
+        else:
+            func_args = func_args_def
+    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, url_prefix=None):
+    # Convert data dictionary to JSON and encode it to bytes
+    if url_prefix:
+        api_base = url_prefix
+    else:
+        api_base= api_base_oai
+    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 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):
+    """
+    """
+    # Receive the instruction
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the initial payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "instructions":     instruction,
+        "input":            messages,
+        "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['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 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['include'] = [] # must be removed if response_id
+            payload['previous_response_id'] = response_id
+            payload['input'] = function_outputs_messages
+        else:
+            break
+
+    return thoughts, text
+
+
+if __name__ == "__main__":
+    ...

{thinking_machine-0.1.7 → thinking_machine-0.1.9}/src/thinking_machine/providers/light.py

@@ -14,7 +14,7 @@ from os import environ
 def respond(messages, instructions, **kwargs):
     """
     """
-    api_key = environ.get("LIGHNING_API_KEY")
+    api_key = environ.get("LIGHTNING_API_KEY")
     api_base = environ.get("LIGHTNING_API_BASE", "https://lightning.ai/api/v1")
     default_model = environ.get("LIGHTNING_DEFAULT_MODEL", "openai/gpt-5.5-2026-04-23")
 
@@ -29,12 +29,9 @@ def respond(messages, instructions, **kwargs):
     payload = {
         "model":            kwargs.get("model", default_model),
         "messages":         instruction_and_contents,
-        "max_tokens":       kwargs.get("max_tokens", 32000),
+        "max_completion_tokens":       kwargs.get("max_tokens", 32000),
         "temperature":      kwargs.get("temperature", 1.0),
-        "reasoning_effort": kwargs.get("reasoning_effort", "high"),
-        "thinking": {
-            "type": "enabled"
-        }
+        "reasoning_effort": kwargs.get("reasoning_effort", "xhigh"),
     }
 
     # Convert data dictionary to JSON and encode it to bytes
@@ -61,7 +58,7 @@ def respond(messages, instructions, **kwargs):
             output = json.loads(response_data)
             message = output['choices'][0]['message']
             text = message['content']
-            thoughts = message['reasoning_content']
+            thoughts = message.get('reasoning_content', '')
 
         return thoughts, text
 

thinking_machine-0.1.9/src/thinking_machine/providers/tink.py

@@ -0,0 +1,188 @@
+# -*- 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
+
+
+api_key = environ.get("TINKER_API_KEY", '')
+default_model = environ.get("TINKER_DEFAULT_MODEL", 'thinkingmachines/Inkling')
+api_base_oai = environ.get("TINKER_OAI_API_BASE", 'https://tinker.thinkingmachines.dev/services/tinker-prod/oai/api/v1')
+api_base_ant = environ.get("TINKER_ANT_API_BASE", 'https://tinker.thinkingmachines.dev/services/tinker-prod/anthropic/api/v1')
+
+
+# Set the mandatory headers
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {api_key}",
+    "User-Agent": "machine-thinking"
+}
+
+
+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_def):
+    try:
+        if isinstance(func_args_def, str):
+            func_args = json.loads(func_args_def)
+        else:
+            func_args = func_args_def
+    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, url_prefix=None):
+    # Convert data dictionary to JSON and encode it to bytes
+    if url_prefix:
+        api_base = url_prefix
+    else:
+        api_base= api_base_oai
+    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 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):
+    """
+    """
+    # Receive the instruction
+    instruction = kwargs.get('system_instruction', instructions)
+
+    # Define the initial payload
+    payload = {
+        "model":            kwargs.get("model", default_model),
+        "instructions":     instruction,
+        "input":            messages,
+        "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['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 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['include'] = [] # must be removed if response_id
+            payload['previous_response_id'] = response_id
+            payload['input'] = function_outputs_messages
+        else:
+            break
+
+    return thoughts, text
+
+
+if __name__ == "__main__":
+    ...

{thinking_machine-0.1.7 → thinking_machine-0.1.9/src/thinking_machine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thinking-machine
-Version: 0.1.7
+Version: 0.1.9
 Summary: A Machine that thinks.
 Author-email: Machina Ratiocinatrix <machina.ratio@gmail.com>, Alexander Fedotov <alex.fedotov@aol.com>
 Project-URL: Homepage, https://github.com/machina-ratiocinatrix/thinking-machine
@@ -42,15 +42,6 @@ Or:
 ```bash
 thinking-machine multilogue.txt > response.txt
 ```
-Or:
-```bash
-thinking-machine -a multilogue.txt | vim
-```
-Or:
-```bash
-thinking-machine -a multilogue.txt > tmp && echo tmp > multilogue.txt
-```
-
 Or use it in your Python code:
 ```Python
 # Python

{thinking_machine-0.1.7 → thinking_machine-0.1.9}/src/thinking_machine.egg-info/SOURCES.txt

@@ -21,10 +21,12 @@ src/thinking_machine/providers/camelids.py
 src/thinking_machine/providers/castor_pollux.py
 src/thinking_machine/providers/depsek.py
 src/thinking_machine/providers/electroid.py
+src/thinking_machine/providers/illuminati.py
 src/thinking_machine/providers/light.py
 src/thinking_machine/providers/openai.py
 src/thinking_machine/providers/qrog.py
 src/thinking_machine/providers/strangelove.py
+src/thinking_machine/providers/tink.py
 tests/test_cli.py
 tests/test_e2e.py
 tests/test_llm_soup.py

{thinking_machine-0.1.7 → thinking_machine-0.1.9}/src/thinking_machine.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
+think = thinking_machine.cli:run
 thinking-machine = thinking_machine.cli:run