abstract-toolserver 0.0.44__tar.gz → 0.0.45__tar.gz

{abstract_toolserver-0.0.44/src/abstract_toolserver.egg-info → abstract_toolserver-0.0.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_toolserver
-Version: 0.0.44
+Version: 0.0.45
 Summary: The abstract_* ecosystem exposed as an API-callable AI toolset: functions become self-describing Flask endpoints with /endpoints discovery and ?help.
 Home-page: https://github.com/AbstractEndeavors/abstract-toolserver
 Author: putkoff

{abstract_toolserver-0.0.44 → abstract_toolserver-0.0.45}/setup.py

@@ -7,7 +7,7 @@ SERVER = ['abstract_flask', 'abstract_utilities']
 
 setuptools.setup(
     name='abstract_toolserver',
-    version='0.0.44',
+    version='0.0.45',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description="The abstract_* ecosystem exposed as an API-callable AI toolset: functions become self-describing Flask endpoints with /endpoints discovery and ?help.",

{abstract_toolserver-0.0.44 → abstract_toolserver-0.0.45}/src/abstract_toolserver/app.py

@@ -67,6 +67,13 @@ def _install_operator_gate(app):
                         "instance": ident.get("instance", ""),
                         "version": ident.get("version") or _discovery.package_version()})
 
+    @app.route("/handoff/<session_id>", methods=["GET"])
+    def _handoff_get(session_id):
+        # the canonical dereference of a handoff pointer: /toolserver/handoff/{id}
+        from .seat import session_resume
+        doc = session_resume(session_id)
+        return jsonify({"result": doc})
+
     @app.before_request
     def _require_operator_token():
         if request.method == "OPTIONS":

{abstract_toolserver-0.0.44 → abstract_toolserver-0.0.45}/src/abstract_toolserver/catalog.py

@@ -5,7 +5,7 @@ Two consumers share everything here:
 
   * the ``ts`` toolset (POST /ts/categories, /ts/list, /ts/call) — served by the
     same register_categories machinery as every other tool, so the public names
-    are ts_categories / ts_list / ts_call.
+    are toolserver_categories / toolserver_list / toolserver_call.
   * POST /mcp — the MCP Streamable-HTTP JSON-RPC transport (routes/__init__.py).
 
 The catalog is the UNION of
@@ -25,7 +25,8 @@ import json
 
 from . import clients
 
-_META_CATEGORY = "ts"
+_META_CATEGORY = "toolserver"
+_META_CATEGORY_ALIAS = "ts"          # pre-rename routes /ts/*, still served
 _DELEGATE_MARK = "[delegated "   # proxy docstrings start "[delegated → <base>] ..."
 
 # Curated one-liners for the known categories (fallback = first few tool names).
@@ -210,9 +211,9 @@ def _short(name, category):
 # ══════════════════════════════════════════════════════════
 # ts_* tool functions (registered under TOOLSETS["ts"])
 # ══════════════════════════════════════════════════════════
-def ts_categories():
+def toolserver_categories():
     """List every tool category (local + online clients) with a tool count and a
-    short summary. Call this first, then ts_list(category), then ts_call(name)."""
+    short summary. Call this first, then toolserver_list(category), then toolserver_call(name)."""
     local = _local_tools()
     cats = {}   # cat -> set(names)
     for name, (cat, _route, _func) in local.items():
@@ -229,7 +230,7 @@ def ts_categories():
     return out
 
 
-def ts_list(category=None):
+def toolserver_list(category=None):
     """Start here, or list exact tools in one category.
 
     With no category, returns a guided category index and copyable next-call
@@ -239,13 +240,13 @@ def ts_list(category=None):
     """
     category = str(category or "").strip().strip("/").lower()
     if not category:
-        categories = ts_categories()
+        categories = toolserver_categories()
         return {
             "start_here": True,
             "workflow": [
                 "Choose a category from categories below.",
-                "Call ts_list again with that category to get exact tool schemas.",
-                "Call ts_call with a returned full tool name and an arguments object.",
+                "Call toolserver_list again with that category to get exact tool schemas.",
+                "Call toolserver_call with a returned full tool name and an arguments object.",
             ],
             "categories": categories,
             "examples": {
@@ -259,7 +260,7 @@ def ts_list(category=None):
                     "arguments": {"path": "tools/toolserver"},
                 },
             },
-            "naming": "ts_call name = <category>_<route>; use names exactly as returned",
+            "naming": "toolserver_call name = <category>_<route>; use names exactly as returned",
         }
     tools, seen = [], set()
     for name, (cat, _route, func) in sorted(_local_tools().items()):
@@ -277,26 +278,26 @@ def ts_list(category=None):
         seen.add(name)
     if not tools:
         return {"category": category, "count": 0, "tools": [],
-                "error": f"unknown or empty category: {category}", "hint": "ts_categories"}
+                "error": f"unknown or empty category: {category}", "hint": "toolserver_categories"}
     return {
         "category": category,
         "count": len(tools),
         "tools": tools,
-        "next": {"tool": "ts_call", "shape": {"name": "<tool name above>",
+        "next": {"tool": "toolserver_call", "shape": {"name": "<tool name above>",
                                                    "arguments": "<object matching its parameters>"}},
     }
 
 
-def ts_call(name=None, arguments=None, client=None, tags=None):
+def toolserver_call(name=None, arguments=None, client=None, tags=None):
     """Invoke a tool by full name (e.g. 'fs_read_file', 'ui_capture'). Args:
-    name, arguments (object of the tool's params, from ts_list), optional client
+    name, arguments (object of the tool's params, from toolserver_list), optional client
     (route a client-provided tool to a specific client id/name) and tags (pick an
     online client matching these tags). Local tools run in-process with the same
     argument coercion and result shape a direct POST to the tool's endpoint gives;
     client tools route to an online provider. Unknown name -> error as data."""
     name = str(name or "").strip()
     if not name:
-        return {"error": "name is required", "hint": "ts_categories → ts_list"}
+        return {"error": "name is required", "hint": "toolserver_categories → toolserver_list"}
     arguments = arguments if isinstance(arguments, dict) else {}
     local = _local_tools()
     if name in local and not client:
@@ -305,7 +306,7 @@ def ts_call(name=None, arguments=None, client=None, tags=None):
         return func(*args, **kwargs)   # raw value; exceptions propagate to the endpoint
     # client-provided (or an explicit client override)
     if name not in local and name not in _client_index() and not client:
-        return {"error": f"unknown tool: {name}", "hint": "ts_categories → ts_list"}
+        return {"error": f"unknown tool: {name}", "hint": "toolserver_categories → toolserver_list"}
     return clients.dispatch(name, _coerce_args(arguments), client=client, tags=tags)
 
 
@@ -317,24 +318,29 @@ def _prune(func, coerced):
         return (), coerced
 
 
+# pre-rename import aliases (tests, external callers)
+ts_categories, ts_list, ts_call = toolserver_categories, toolserver_list, toolserver_call
+
+
 def get_toolset():
-    return {_META_CATEGORY: {"categories": ts_categories, "list": ts_list, "call": ts_call}}
+    routes = {"categories": toolserver_categories, "list": toolserver_list, "call": toolserver_call}
+    return {_META_CATEGORY: routes, _META_CATEGORY_ALIAS: dict(routes)}
 
 
 # ══════════════════════════════════════════════════════════
 # MCP Streamable-HTTP  (JSON-RPC 2.0 over POST /mcp)
 # ══════════════════════════════════════════════════════════
 _META_TOOL_SCHEMAS = [
-    {"name": "ts_categories",
+    {"name": "toolserver_categories",
      "description": "List toolserver tool categories (local + online clients) with counts. "
-                    "Call this first, then ts_list.",
+                    "Call this first, then toolserver_list.",
      "inputSchema": {"type": "object", "properties": {}}},
-    {"name": "ts_list",
+    {"name": "toolserver_list",
      "description": "List the tools in one category, with each tool's parameters. "
-                    "Arg: category (from ts_categories).",
+                    "Arg: category (from toolserver_categories).",
      "inputSchema": {"type": "object", "properties": {"category": {"type": "string"}},
                      "required": ["category"]}},
-    {"name": "ts_call",
+    {"name": "toolserver_call",
      "description": "Invoke a toolserver tool by full name. Args: name, arguments "
                     "(object of the tool's params), optional client (id/name) and tags "
                     "(list) to route a client-provided tool to a specific online client.",
@@ -346,6 +352,9 @@ _META_TOOL_SCHEMAS = [
                      "required": ["name"]}},
 ]
 _META_NAMES = {t["name"] for t in _META_TOOL_SCHEMAS}
+_META_NAME_ALIASES = {"ts_categories": "toolserver_categories", "ts_list": "toolserver_list",
+                      "ts_call": "toolserver_call"}      # pre-rename names, still accepted
+_META_NAMES |= set(_META_NAME_ALIASES)
 
 
 def _server_version():
@@ -384,22 +393,23 @@ def _as_text(result):
 
 def mcp_tools_call(name, arguments):
     """(result_obj, is_error) for an MCP tools/call. Handles the three meta tools
-    by name and, in flat mode, any tool by its full name (via ts_call)."""
+    by name and, in flat mode, any tool by its full name (via toolserver_call)."""
     name = str(name or "")
+    name = _META_NAME_ALIASES.get(name, name)
     arguments = arguments if isinstance(arguments, dict) else {}
     try:
-        if name == "ts_categories":
-            return ts_categories(), False
-        if name == "ts_list":
-            r = ts_list(category=arguments.get("category"))
+        if name == "toolserver_categories":
+            return toolserver_categories(), False
+        if name == "toolserver_list":
+            r = toolserver_list(category=arguments.get("category"))
             return r, bool(r.get("error"))
-        if name == "ts_call":
-            r = ts_call(name=arguments.get("name"),
+        if name == "toolserver_call":
+            r = toolserver_call(name=arguments.get("name"),
                         arguments=arguments.get("arguments") or {},
                         client=arguments.get("client"), tags=arguments.get("tags"))
             return r, bool(isinstance(r, dict) and "error" in r)
         # flat-mode: name is the tool itself
-        r = ts_call(name=name, arguments=arguments)
+        r = toolserver_call(name=name, arguments=arguments)
         return r, bool(isinstance(r, dict) and "error" in r)
     except Exception as e:  # noqa: BLE001 — tool raised → MCP isError
         return {"error": str(e)}, True

{abstract_toolserver-0.0.44 → abstract_toolserver-0.0.45}/src/abstract_toolserver/mcp.py

@@ -449,25 +449,25 @@ def load_tools():
 # ── categorical mode ────────────────────────────────────────────────────────
 # Flat mode exposes all ~146 endpoints as distinct tools — every schema rides in
 # the prompt EVERY turn (~5k tok) whether used or not. Categorical mode exposes 3
-# meta-tools and lets the model discover on demand: ts_categories → ts_list(cat)
-# → ts_call(name), cutting the standing toolset cost to a few hundred tokens.
+# meta-tools and lets the model discover on demand: toolserver_categories → toolserver_list(cat)
+# → toolserver_call(name), cutting the standing toolset cost to a few hundred tokens.
 # Enable with AC_MCP_MODE=categorical. (Schemas come from the same cached
-# discovery, so ts_list is instant.)
+# discovery, so toolserver_list is instant.)
 CATEGORICAL = os.environ.get("AC_MCP_MODE", "flat").lower() in ("cat", "categorical", "category")
 
 META_TOOLS = [
-    {"name": "ts_categories",
+    {"name": "toolserver_categories",
      "description": "List abstract_toolserver tool categories (e.g. web, vm, vmpool, ui, "
-                    "todo, fs, seat, session, db) with counts. Call this first, then ts_list.",
+                    "todo, fs, seat, session, db) with counts. Call this first, then toolserver_list.",
      "inputSchema": {"type": "object", "properties": {}}},
-    {"name": "ts_list",
+    {"name": "toolserver_list",
      "description": "List the toolserver tools in one category, with each tool's parameters. "
-                    "Args: category (from ts_categories).",
+                    "Args: category (from toolserver_categories).",
      "inputSchema": {"type": "object", "properties": {"category": {"type": "string"}},
                      "required": ["category"]}},
-    {"name": "ts_call",
+    {"name": "toolserver_call",
      "description": "Invoke a toolserver tool by full name (e.g. 'fs_read_file'). Args: name, "
-                    "arguments (object of the tool's params, from ts_list).",
+                    "arguments (object of the tool's params, from toolserver_list).",
      "inputSchema": {"type": "object",
                      "properties": {"name": {"type": "string"}, "arguments": {"type": "object"}},
                      "required": ["name"]}},
@@ -500,17 +500,22 @@ def _categories(tools):
     return [{"category": k, "tools": n} for k, n in sorted(c.items())]
 
 
+_META_ALIASES = {"ts_categories": "toolserver_categories", "ts_list": "toolserver_list",
+                 "ts_call": "toolserver_call"}      # pre-rename names, still accepted
+
+
 def _handle_meta(name, args, tools, url_by_name):
     """(out, is_error) for a categorical meta-tool call."""
-    if name == "ts_categories":
+    name = _META_ALIASES.get(name, name)
+    if name == "toolserver_categories":
         return _categories(tools), False
-    if name == "ts_list":
+    if name == "toolserver_list":
         cat = str(args.get("category", "")).strip().strip("/").lower()
         sel = [t for t in tools if _category_of(t) == cat]
         listing = [{"name": t["name"], "description": t.get("description", ""),
                     "inputSchema": t.get("inputSchema", {})} for t in sel]
         return {"category": cat, "count": len(listing), "tools": listing}, (not sel)
-    if name == "ts_call":
+    if name == "toolserver_call":
         target = args.get("name")
         call_args = _coerce(args.get("arguments") or {})
         url = url_by_name.get(target)
@@ -697,14 +702,15 @@ def serve_mcp():
                                            "text": json.dumps(out, indent=2, default=str)}],
                               "isError": bool(is_err)})
                 continue
-            if CATEGORICAL and name in ("ts_categories", "ts_list", "ts_call"):
+            if CATEGORICAL and name in ("toolserver_categories", "toolserver_list", "toolserver_call",
+                            "ts_categories", "ts_list", "ts_call"):
                 try:
                     out, is_err = _handle_meta(name, args, tools_cache, url_by_name)
                 except Exception as e:
                     out, is_err = {"error": str(e)}, True
-                gov_tool = str(args.get("name") or "") if name == "ts_call" else name
+                gov_tool = str(args.get("name") or "") if name in ("toolserver_call", "ts_call") else name
                 text = govern_result(json.dumps(out, indent=2, default=str), gov_tool,
-                                     args.get("arguments") if name == "ts_call" else args)
+                                     args.get("arguments") if name in ("toolserver_call", "ts_call") else args)
                 _result(id_, {"content": [{"type": "text", "text": text}],
                               "isError": bool(is_err)})
                 continue

{abstract_toolserver-0.0.44 → abstract_toolserver-0.0.45}/src/abstract_toolserver/seat.py

@@ -387,9 +387,8 @@ def session_resume(session_id):
 
 
 def get_toolset():
-    # seat_rollover (the phase gate) is UNMOUNTED for now (operator 2026-10-01):
-    # the serve owns rolls; the session chain endpoints below are the contract.
     return {"seat": {"report": seat_report, "state": seat_state,
+                     "rollover": seat_rollover,
                      "session_register": session_register,
                      "session_handoff": session_handoff,
                      "session_resume": session_resume}}

{abstract_toolserver-0.0.44 → abstract_toolserver-0.0.45/src/abstract_toolserver.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_toolserver
-Version: 0.0.44
+Version: 0.0.45
 Summary: The abstract_* ecosystem exposed as an API-callable AI toolset: functions become self-describing Flask endpoints with /endpoints discovery and ?help.
 Home-page: https://github.com/AbstractEndeavors/abstract-toolserver
 Author: putkoff

{abstract_toolserver-0.0.44 → abstract_toolserver-0.0.45}/tests/test_catalog_start.py

@@ -21,5 +21,5 @@ def test_ts_list_without_category_is_a_guided_start():
 def test_ts_list_category_includes_next_call_shape():
     result = ts_list("channel")
     assert result["tools"]
-    assert result["next"]["tool"] == "ts_call"
+    assert result["next"]["tool"] == "toolserver_call"
     assert result["next"]["shape"]["name"] == "<tool name above>"