weftai 0.1.0a1__tar.gz

weftai-0.1.0a1/.gitignore

@@ -0,0 +1,30 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.eggs/
+.coverage
+.coverage.*
+htmlcov/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.pyright/
+.tox/
+.env
+.env.*
+!.env.example
+uv.lock.bak
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+*.tsbuildinfo
+.coverage.*
+htmlcov/

weftai-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rex Technologies
+
+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.

weftai-0.1.0a1/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.5
+Name: weftai
+Version: 0.1.0a1
+Summary: Weftai: composable AI workflows (Rex Technologies)
+Project-URL: Homepage, https://github.com/tochi-mba/weftai-python
+Project-URL: Documentation, https://github.com/tochi-mba/weftai-python/tree/main/docs
+Project-URL: Source, https://github.com/tochi-mba/weftai-python
+Author: Rex Technologies
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,llm,tools,workflows
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: pydantic<3,>=2.10
+Provides-Extra: all
+Requires-Dist: weftai-cli; extra == 'all'
+Requires-Dist: weftai-mcp; extra == 'all'
+Requires-Dist: weftai-providers; extra == 'all'
+Requires-Dist: weftai-testing; extra == 'all'
+Description-Content-Type: text/markdown
+
+# weftai
+
+Core runtime and adapter catalog. Install: `pip install weftai`.
+
+See the [workspace README](https://github.com/tochi-mba/weftai-python).

weftai-0.1.0a1/README.md

@@ -0,0 +1,5 @@
+# weftai
+
+Core runtime and adapter catalog. Install: `pip install weftai`.
+
+See the [workspace README](https://github.com/tochi-mba/weftai-python).

weftai-0.1.0a1/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling", "hatch-cada>=1.0.3"]
+build-backend = "hatchling.build"
+
+[project]
+name = "weftai"
+version = "0.1.0a1"
+description = "Weftai: composable AI workflows (Rex Technologies)"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [{ name = "Rex Technologies" }]
+keywords = ["ai", "agents", "workflows", "llm", "tools"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+]
+dependencies = ["pydantic>=2.10,<3"]
+
+[project.optional-dependencies]
+all = ["weftai-providers", "weftai-mcp", "weftai-cli", "weftai-testing"]
+
+[project.urls]
+Homepage = "https://github.com/tochi-mba/weftai-python"
+Documentation = "https://github.com/tochi-mba/weftai-python/tree/main/docs"
+Source = "https://github.com/tochi-mba/weftai-python"
+
+[tool.hatch.metadata.hooks.cada]
+strategy = "pin"
+
+[tool.hatch.build]
+dev-mode-dirs = ["src"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/weftai"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/weftai", "README.md", "LICENSE"]

weftai-0.1.0a1/src/weftai/__init__.py

@@ -0,0 +1,119 @@
+"""Weftai: composable AI workflows. A Rex Technologies product."""
+
+from __future__ import annotations
+
+import pkgutil
+
+__path__ = pkgutil.extend_path(__path__, __name__)
+
+from pydantic import BaseModel, Field, TypeAdapter, ValidationError
+
+from weftai.errors import (
+    DefinitionError,
+    LimitExceededError,
+    PlanValidationError,
+    RefResolutionError,
+    RegistryError,
+    StepExecutionError,
+    WeftaiError,
+    format_issue,
+    format_issues,
+)
+from weftai.executor.runtime import create_runtime
+from weftai.executor.types import DEFAULT_LIMITS, TRACE_VERSION
+from weftai.format.formatter import create_formatter
+from weftai.format.sanitize import format_property, sanitize_label
+from weftai.format.tokens import DEFAULT_BUDGETS, estimate_tokens
+from weftai.ids import OPERATION_NAME_PATTERN, STEP_ID_PATTERN, is_valid_operation_name, is_valid_step_id
+from weftai.operation import define_operation, define_operation_for, provenance_type
+from weftai.plan.types import PlanSchema, PlanStepSchema
+from weftai.plan.validate import validate_plan
+from weftai.refs.syntax import REF_PATTERN_SOURCE, format_ref, parse_ref
+from weftai.registry import create_registry
+from weftai.registry.describe import describe_operations
+from weftai.registry.plan_schema import build_plan_schema
+from weftai.results.resolve import resolve_ref
+from weftai.results.session import session_view
+from weftai.results.store import create_memory_store
+from weftai.results.types import DEFAULT_SESSION_ID, DEFAULT_STORE_LIMITS
+from weftai.schema.json import input_json_schema
+from weftai.schema.ref import is_ref_schema, ref, ref_meta
+from weftai.schema.summarize import summarize_schema
+from weftai.schema.types import (
+    collection,
+    groups,
+    is_step_output,
+    make_collection,
+    value,
+    with_sources,
+)
+from weftai.std.fields import field_names, resolve_field
+from weftai.std.match import FILTER_OPS, matches_filter
+from weftai.std.operations import STANDARD_OP_KINDS, standard_operations
+from weftai.trace import build_trace
+
+VERSION = "0.1.0"
+
+__all__ = [
+    "BaseModel",
+    "DEFAULT_BUDGETS",
+    "DEFAULT_LIMITS",
+    "DEFAULT_SESSION_ID",
+    "DEFAULT_STORE_LIMITS",
+    "DefinitionError",
+    "FILTER_OPS",
+    "Field",
+    "LimitExceededError",
+    "OPERATION_NAME_PATTERN",
+    "PlanSchema",
+    "PlanStepSchema",
+    "PlanValidationError",
+    "REF_PATTERN_SOURCE",
+    "RefResolutionError",
+    "RegistryError",
+    "STANDARD_OP_KINDS",
+    "STEP_ID_PATTERN",
+    "StepExecutionError",
+    "TRACE_VERSION",
+    "TypeAdapter",
+    "VERSION",
+    "ValidationError",
+    "WeftaiError",
+    "build_plan_schema",
+    "build_trace",
+    "collection",
+    "create_formatter",
+    "create_memory_store",
+    "create_registry",
+    "create_runtime",
+    "define_operation",
+    "define_operation_for",
+    "describe_operations",
+    "estimate_tokens",
+    "field_names",
+    "format_issue",
+    "format_issues",
+    "format_property",
+    "format_ref",
+    "groups",
+    "input_json_schema",
+    "is_ref_schema",
+    "is_step_output",
+    "is_valid_operation_name",
+    "is_valid_step_id",
+    "make_collection",
+    "matches_filter",
+    "parse_ref",
+    "provenance_type",
+    "ref",
+    "ref_meta",
+    "resolve_field",
+    "resolve_ref",
+    "sanitize_label",
+    "session_view",
+    "standard_operations",
+    "summarize_schema",
+    "validate_plan",
+    "value",
+    "with_sources",
+]

weftai-0.1.0a1/src/weftai/_abort.py

@@ -0,0 +1,74 @@
+"""AbortController / AbortSignal, matching the DOM API the TypeScript runtime uses."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+class AbortError(Exception):
+    """Raised or stored as `signal.reason` when a step or plan is cancelled."""
+
+    def __init__(self, message: str = "This operation was aborted") -> None:
+        super().__init__(message)
+        self.name = "AbortError"
+
+
+class AbortSignal:
+    def __init__(self) -> None:
+        self._aborted = False
+        self._reason: object = None
+        self._listeners: list[tuple[Callable[[], None], bool]] = []
+
+    @property
+    def aborted(self) -> bool:
+        return self._aborted
+
+    @property
+    def reason(self) -> object:
+        return self._reason
+
+    def add_event_listener(
+        self,
+        event: str,
+        callback: Callable[[], None],
+        *,
+        once: bool = False,
+    ) -> None:
+        if event != "abort":
+            return
+        if self._aborted:
+            callback()
+            return
+        self._listeners.append((callback, once))
+
+    def remove_event_listener(self, event: str, callback: Callable[[], None]) -> None:
+        if event != "abort":
+            return
+        self._listeners = [(cb, once) for cb, once in self._listeners if cb is not callback]
+
+    def _abort(self, reason: object) -> None:
+        if self._aborted:
+            return
+        self._aborted = True
+        self._reason = reason if reason is not None else AbortError()
+        listeners = list(self._listeners)
+        self._listeners.clear()
+        for callback, _once in listeners:
+            callback()
+
+
+class AbortController:
+    def __init__(self) -> None:
+        self.signal = AbortSignal()
+
+    def abort(self, reason: object = None) -> None:
+        self.signal._abort(reason)
+
+
+def is_abort_like(error: object) -> bool:
+    if isinstance(error, AbortError):
+        return True
+    if isinstance(error, BaseException) and getattr(error, "name", None) == "AbortError":
+        return True
+    return False

weftai-0.1.0a1/src/weftai/adapter/__init__.py

@@ -0,0 +1,23 @@
+from weftai.adapter.bind import bind_tool, parse_tool_arguments
+from weftai.adapter.catalog import (
+    CAPABILITIES,
+    CHINESE_CAPABILITIES,
+    LOCAL_CAPABILITIES,
+    WESTERN_CAPABILITIES,
+    lookup_capability,
+    require_capability,
+)
+from weftai.adapter.dialects import compile_plan_schema, contains_any_of
+
+__all__ = [
+    "CAPABILITIES",
+    "CHINESE_CAPABILITIES",
+    "LOCAL_CAPABILITIES",
+    "WESTERN_CAPABILITIES",
+    "bind_tool",
+    "compile_plan_schema",
+    "contains_any_of",
+    "lookup_capability",
+    "parse_tool_arguments",
+    "require_capability",
+]

weftai-0.1.0a1/src/weftai/adapter/bind.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import inspect
+import json
+from typing import Any
+
+from weftai.adapter.dialects import compile_plan_schema
+from weftai.plan.types import PlanSchema
+
+
+async def resolve_ctx(ctx: Any) -> Any:
+    if callable(ctx):
+        result = ctx()
+        if inspect.isawaitable(result):
+            return await result
+        return result
+    return ctx
+
+
+def bind_tool(runtime: Any, spec: dict[str, Any], context: dict[str, Any]) -> dict[str, Any]:
+    include = spec.get("include")
+    scoped = runtime.registry.filter(include or (lambda _op: True))
+    allow_writes = spec.get("allowWrites")
+    if allow_writes is None:
+        allow_writes = any(op.effects == "write" for op in scoped.operations)
+    dialect = spec.get("dialect") or "union"
+    schema = compile_plan_schema(scoped.operations, dialect, {"strict": spec.get("strict")})
+    description = spec.get("description") or scoped.describe()
+    on_invalid = spec.get("onInvalid") or "text"
+
+    async def execute(input: object) -> dict[str, Any]:
+        parsed = PlanSchema.safe_parse(input)
+        if not parsed.success:
+            text = format_invalid_plan([{"path": i.path, "message": i.message} for i in parsed.issues])
+            if on_invalid == "throw":
+                raise ValueError(text)
+            return {"text": text, "ok": False}
+        result = await runtime.execute(
+            parsed.data,
+            {
+                "ctx": await resolve_ctx(context["ctx"]),
+                "session": {"id": context["sessionId"]},
+                "allowWrites": allow_writes,
+                "include": spec.get("include"),
+            },
+        )
+        return {"text": result["text"], "ok": result["ok"]}
+
+    async def handle(input: object) -> str:
+        return (await execute(input))["text"]
+
+    return {
+        "name": spec["name"],
+        "description": description,
+        "schema": schema,
+        "dialect": dialect,
+        "execute": execute,
+        "handle": handle,
+    }
+
+
+def format_invalid_plan(issues: list[dict[str, Any]]) -> str:
+    if len(issues) == 0:
+        return "Could not read this plan: the value is not a plan."
+    lines = []
+    for issue in issues:
+        path = ".".join(str(p) for p in issue.get("path") or ())
+        where = "the plan" if path == "" else f"'{path}'"
+        lines.append(f"{where}: {issue['message']}")
+    return "Could not read this plan. " + " ".join(lines)
+
+
+def parse_tool_arguments(raw: object) -> dict[str, object]:
+    if raw is None:
+        return {"ok": True, "value": {}}
+    if isinstance(raw, dict | list):
+        return {"ok": True, "value": raw}
+    if isinstance(raw, bool):
+        return {
+            "ok": False,
+            "message": "Tool arguments must be a JSON object or a JSON string, not boolean.",
+        }
+    if isinstance(raw, int | float):
+        return {
+            "ok": False,
+            "message": "Tool arguments must be a JSON object or a JSON string, not number.",
+        }
+    if not isinstance(raw, str):
+        return {
+            "ok": False,
+            "message": f"Tool arguments must be a JSON object or a JSON string, not {type(raw).__name__}.",
+        }
+    trimmed = raw.strip()
+    if len(trimmed) == 0:
+        return {"ok": True, "value": {}}
+    try:
+        return {"ok": True, "value": json.loads(trimmed)}
+    except json.JSONDecodeError:
+        return {"ok": False, "message": f"Tool arguments are not valid JSON: {trimmed[:80]}."}

weftai-0.1.0a1/src/weftai/adapter/catalog/__init__.py

@@ -0,0 +1,19 @@
+from weftai.adapter.catalog.chinese import CHINESE_CAPABILITIES
+from weftai.adapter.catalog.local import LOCAL_CAPABILITIES
+from weftai.adapter.catalog.lookup import (
+    CAPABILITIES,
+    capabilities_for,
+    lookup_capability,
+    require_capability,
+)
+from weftai.adapter.catalog.western import WESTERN_CAPABILITIES
+
+__all__ = [
+    "CAPABILITIES",
+    "CHINESE_CAPABILITIES",
+    "LOCAL_CAPABILITIES",
+    "WESTERN_CAPABILITIES",
+    "capabilities_for",
+    "lookup_capability",
+    "require_capability",
+]