noeta-sdk 0.1.0__tar.gz

noeta_sdk-0.1.0/.gitignore

@@ -0,0 +1,50 @@
+# Claude Code local private config (skills travel with the project; not ignored)
+.claude/settings.local.json
+.claude/*.local.*
+.claude/worktrees/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+.venv/
+venv/
+env/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.import_linter_cache/
+.tox/
+htmlcov/
+.coverage
+.coverage.*
+dist/
+build/
+*.egg
+node_modules/
+
+# IDE / Editor
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Local demo / scratch artifacts
+*.sqlite
+*.sqlite-shm
+*.sqlite-wal
+*.tmp.xml
+*.tmp
+
+# Local runtime config (contains api_key); only the noeta.config.example.json template is committed
+/noeta.config.json
+
+# Local artifacts from Playwright MCP test runs (console logs / page snapshots)
+/.playwright-mcp/

noeta_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: noeta-sdk
+Version: 0.1.0
+Summary: Noeta SDK: the thin in-process client surface (noeta.sdk facade — query / Client / Options / tool / extension interfaces) over the noeta-runtime engine. Like claude-agent-sdk / LangChain: import noeta.sdk, run an agent in-process; no engine internals, no HTTP.
+Project-URL: Homepage, https://github.com/initxy/noeta
+Project-URL: Repository, https://github.com/initxy/noeta
+Author: The Noeta Authors
+License-Expression: Apache-2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: noeta-runtime
+Description-Content-Type: text/markdown
+
+# noeta-sdk
+
+The thin in-process **client surface** (`noeta.sdk` facade — `query` / `Client`
+/ `Options` / `tool` / extension interfaces) over the
+[noeta-runtime](https://github.com/initxy/noeta) engine. Like claude-agent-sdk /
+LangChain: `import noeta.sdk`, run an agent in-process; no engine internals,
+no HTTP.
+
+Part of the [Noeta](https://github.com/initxy/noeta) workspace. Apache-2.0.
+
+```bash
+pip install -e packages/noeta-sdk
+```

noeta_sdk-0.1.0/README.md

@@ -0,0 +1,13 @@
+# noeta-sdk
+
+The thin in-process **client surface** (`noeta.sdk` facade — `query` / `Client`
+/ `Options` / `tool` / extension interfaces) over the
+[noeta-runtime](https://github.com/initxy/noeta) engine. Like claude-agent-sdk /
+LangChain: `import noeta.sdk`, run an agent in-process; no engine internals,
+no HTTP.
+
+Part of the [Noeta](https://github.com/initxy/noeta) workspace. Apache-2.0.
+
+```bash
+pip install -e packages/noeta-sdk
+```

noeta_sdk-0.1.0/noeta/client/__init__.py

@@ -0,0 +1,61 @@
+"""``noeta.client`` — the SDK public face.
+
+This package exposes the *library user* entrypoints with a Claude-Agent-SDK
+shape — lightweight sugar types that compile into the canonical
+``noeta.agent.spec`` identity objects the runtime hosts register and resolve.
+
+Slice 4a (this file) lands:
+
+* :class:`Options` — the human-friendly recipe dataclass.
+* :func:`compile_options` — pure function turning ``Options`` into
+  ``(main_AgentSpec, tuple_of_descendant_AgentSpecs)``.
+* :func:`builtin_tool_ref` — resolve a built-in tool name to its canonical
+  :class:`~noeta.agent.spec.ToolRef` (part of the SDK "batteries" parts table;
+  shared by :func:`compile_options` for string tool entries and by callers
+  who want to build spec tool lists manually).
+
+Future slices (4b/4c):
+
+* ``Client`` — a runtime host that wires compiled specs to a provider +
+  storage and exposes ``start``/``send_goal``/… methods.
+* ``query`` — one-shot ``Iterator[EventEnvelope]`` driver.
+* ``as_messages`` — event-envelope → human-readable message view.
+"""
+
+from noeta.client.client import Client, query
+from noeta.client.host import SdkHost
+from noeta.client.messages import (
+    AssistantMessage,
+    Result,
+    ToolResultView,
+    ToolUse,
+    UserMessage,
+    as_messages,
+)
+from noeta.client.options import (
+    AgentDefinition,
+    Options,
+    SystemPromptPreset,
+    compile_options,
+    register_preset_prompt,
+)
+from noeta.client.parts import builtin_tool_ref
+
+
+__all__ = [
+    "AgentDefinition",
+    "AssistantMessage",
+    "Client",
+    "Options",
+    "Result",
+    "SdkHost",
+    "SystemPromptPreset",
+    "ToolResultView",
+    "ToolUse",
+    "UserMessage",
+    "as_messages",
+    "builtin_tool_ref",
+    "compile_options",
+    "query",
+    "register_preset_prompt",
+]

noeta_sdk-0.1.0/noeta/client/capabilities.py

@@ -0,0 +1,49 @@
+"""capabilities — the SDK-side projections the app's ``/capabilities`` reads.
+
+The app product drives the engine only through ``noeta.sdk``; the composer's
+selectable enums (permission /
+effort modes) and the per-model vision gate are runtime facts the SDK already
+depends on, so they are projected here and re-exported through ``noeta.sdk``
+rather than letting the backend reach for a runtime internal (``noeta.providers``
+is forbidden to ``noeta.agent.backend``).
+
+These are small, pure projections — no state, no I/O — kept together so the one
+public capabilities surface is legible.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+from noeta.client.options import _EFFORT_MODES, _PERMISSION_MODES
+
+
+def permission_modes() -> tuple[str, ...]:
+    """The legal :attr:`Options.permission_mode` values, sorted (composer enum)."""
+    return tuple(sorted(_PERMISSION_MODES))
+
+
+def effort_modes() -> tuple[str, ...]:
+    """The legal :attr:`Options.effort` values, sorted (composer enum)."""
+    return tuple(sorted(_EFFORT_MODES))
+
+
+def model_capabilities(models: Sequence[str]) -> dict[str, dict[str, bool]]:
+    """Per-model ``{supports_vision: bool}`` for the image-attach gate.
+
+    Parallel to the plain ``models`` string list. Each selector is resolved the
+    SAME way the Responses vision guard does
+    (``resolve_alias`` → ``CATALOG.get``): a friendly alias (``opus`` / ``sonnet``
+    / ``haiku``) maps to its real id first; an uncatalogued / unknown selector
+    (test stubs like ``stub-model``) has no spec and is conservatively reported
+    non-vision — fail-closed, never advertise vision we cannot vouch for.
+    """
+    from noeta.providers import catalog
+
+    out: dict[str, dict[str, bool]] = {}
+    for model in models:
+        spec = catalog.CATALOG.get(catalog.resolve_alias(model))
+        out[model] = {
+            "supports_vision": bool(spec is not None and spec.supports_vision)
+        }
+    return out