vectorsmith 0.1.0__py3-none-any.whl

vectorsmith/__init__.py

@@ -0,0 +1,31 @@
+"""VectorSmith application API.
+
+In-process (LangChain, LangGraph, OpenAI Agents, Anthropic SDK)::
+
+    from vectorsmith import load_tools   # LangChain / LangGraph
+    from vectorsmith import connect      # call() or .as_openai_agents() / .as_anthropic()
+
+MCP hosts (Claude Desktop, Claude Code, Codex, Cursor)::
+
+    vectorsmith serve tools.yaml --name invoices
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from vectorsmith.runtime import BoundTools, connect
+
+if TYPE_CHECKING:
+    from vectorsmith.langchain_tools import Toolset
+    from vectorsmith.langchain_tools import load_tools as load_tools
+
+__all__ = ["BoundTools", "Toolset", "connect", "load_tools"]
+
+
+def __getattr__(name: str) -> Any:
+    if name in {"load_tools", "Toolset"}:
+        from vectorsmith.langchain_tools import Toolset, load_tools
+
+        return {"load_tools": load_tools, "Toolset": Toolset}[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

vectorsmith/anthropic.py

@@ -0,0 +1,42 @@
+"""Anthropic Messages API tools from a tools.yaml.
+
+    pip install "vectorsmith[qdrant]" anthropic
+    from vectorsmith.anthropic import load_tools
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from vectorsmith.runtime import BoundTools, connect
+
+
+class AnthropicToolset:
+    """``tools`` for ``messages.create``, plus ``execute`` for ``tool_use`` blocks."""
+
+    def __init__(self, bound: BoundTools) -> None:
+        self._bound = bound
+        self.tools = bound.as_anthropic()
+
+    @property
+    def names(self) -> list[str]:
+        return self._bound.names
+
+    async def execute(self, name: str, tool_input: Mapping[str, Any] | None = None) -> str:
+        result = await self._bound.call(name, tool_input)
+        return json.dumps(result)
+
+    async def aclose(self) -> None:
+        await self._bound.aclose()
+
+
+def load_tools(
+    *sources: str | Path | dict[str, Any],
+    env: Mapping[str, str] | None = None,
+    env_file: str | Path | None = None,
+) -> AnthropicToolset:
+    """Compile tools.yaml into Anthropic tool defs + an in-process dispatcher."""
+    return AnthropicToolset(connect(*sources, env=env, env_file=env_file))

vectorsmith/langchain.py

@@ -0,0 +1,5 @@
+"""LangChain adapter. Same as ``from vectorsmith import load_tools``."""
+
+from vectorsmith.langchain_tools import Toolset, load_tools
+
+__all__ = ["Toolset", "load_tools"]

vectorsmith/langchain_tools.py

@@ -0,0 +1,110 @@
+"""LangChain / LangGraph tools from a tools.yaml.
+
+Application code: write YAML, then ``from vectorsmith import load_tools``.
+Hosts that cannot import Python (Claude Desktop, Codex, Cursor) use
+``vectorsmith serve`` instead. Same YAML.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from langchain_core.tools import BaseTool, StructuredTool
+from pydantic import BaseModel, Field, create_model
+
+from vectorsmith.runtime import BoundTools, connect
+from vectorsmith_core.api import CallContext
+from vectorsmith_core.execute.engine import Engine
+
+_JSON_TO_PY: dict[str, type] = {
+    "string": str,
+    "integer": int,
+    "number": float,
+    "boolean": bool,
+}
+
+
+class Toolset(list[BaseTool]):
+    """LangChain tools plus the engines that back them. Call ``aclose`` when done."""
+
+    def __init__(self, tools: Sequence[BaseTool], engines: Sequence[Engine]) -> None:
+        super().__init__(tools)
+        self._engines = list(engines)
+
+    async def aclose(self) -> None:
+        for engine in self._engines:
+            await engine.aclose()
+
+
+def _py_type(spec: dict[str, Any]) -> type:
+    if spec.get("type") == "array":
+        item = _JSON_TO_PY.get((spec.get("items") or {}).get("type", "string"), str)
+        return list[item]  # type: ignore[valid-type]
+    return _JSON_TO_PY.get(str(spec.get("type", "string")), str)
+
+
+def _args_model(tool_name: str, input_schema: dict[str, Any]) -> type[BaseModel]:
+    props = input_schema.get("properties") or {}
+    required = set(input_schema.get("required") or [])
+    fields: dict[str, Any] = {}
+    for key, spec in props.items():
+        typ = _py_type(spec if isinstance(spec, dict) else {})
+        desc = spec.get("description") if isinstance(spec, dict) else None
+        if key in required:
+            fields[key] = (typ, Field(..., description=desc))
+        else:
+            default = spec.get("default") if isinstance(spec, dict) else None
+            fields[key] = (typ | None, Field(default, description=desc))
+    if not fields:
+        return create_model(f"{tool_name}Args")
+    return create_model(f"{tool_name}Args", **fields)
+
+
+def _bind(engine: Engine, name: str, schema: dict[str, Any]) -> StructuredTool:
+    async def _arun(**kwargs: Any) -> dict[str, Any]:
+        clean = {k: v for k, v in kwargs.items() if v is not None}
+        result = await engine.call(
+            name, clean, ctx=CallContext(request_id=str(uuid.uuid4()))
+        )
+        return result.model_dump()
+
+    def _run(**kwargs: Any) -> dict[str, Any]:
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(_arun(**kwargs))
+        raise RuntimeError(f"tool {name!r} must be awaited in an async context")
+
+    return StructuredTool(
+        name=name,
+        description=schema.get("description") or name,
+        args_schema=_args_model(name, schema.get("inputSchema") or {}),
+        coroutine=_arun,
+        func=_run,
+    )
+
+
+def toolset_from_bound(bound: BoundTools) -> Toolset:
+    tools: list[BaseTool] = []
+    for engine in bound._engines:
+        for schema in engine.project.mcp_tool_schemas():
+            tools.append(_bind(engine, str(schema["name"]), schema))
+    return Toolset(tools, bound._engines)
+
+
+def load_tools(
+    *sources: str | Path | dict[str, Any],
+    env: Mapping[str, str] | None = None,
+    env_file: str | Path | None = None,
+) -> Toolset:
+    """Compile one or more tools.yaml files into LangChain / LangGraph tools.
+
+    >>> from vectorsmith import load_tools
+    >>> tools = load_tools("tools.invoices.yaml", "tools.tickets.yaml")
+    >>> # pass ``tools`` into create_agent / create_react_agent; await tools.aclose()
+    """
+    return connect(*sources, env=env, env_file=env_file).as_langchain()

vectorsmith/langgraph.py

@@ -0,0 +1,5 @@
+"""LangGraph adapter. Same LangChain tools (`ToolNode`, `create_react_agent`)."""
+
+from vectorsmith.langchain_tools import Toolset, load_tools
+
+__all__ = ["Toolset", "load_tools"]

vectorsmith/openai_agents.py

@@ -0,0 +1,69 @@
+"""OpenAI Agents SDK tools from a tools.yaml.
+
+    pip install "vectorsmith[qdrant,openai-agents]"
+    from vectorsmith.openai_agents import load_tools
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from vectorsmith.runtime import BoundTools, connect
+
+
+class OpenAIAgentToolset(list[Any]):
+    """FunctionTool list plus ``aclose`` for the backing engines."""
+
+    def __init__(self, tools: Sequence[Any], bound: BoundTools) -> None:
+        super().__init__(tools)
+        self._bound = bound
+
+    async def aclose(self) -> None:
+        await self._bound.aclose()
+
+
+def _function_tool(bound: BoundTools, schema: dict[str, Any]) -> Any:
+    try:
+        from agents import FunctionTool
+    except ImportError as exc:
+        raise ImportError(
+            "OpenAI Agents SDK is required. Install with: "
+            'pip install "vectorsmith[openai-agents]"'
+        ) from exc
+
+    name = str(schema["name"])
+    params = schema.get("inputSchema") or {"type": "object", "properties": {}}
+
+    async def _on_invoke(_ctx: Any, raw: str) -> str:
+        try:
+            args = json.loads(raw) if raw else {}
+        except json.JSONDecodeError:
+            args = {}
+        if not isinstance(args, dict):
+            return json.dumps({"error": "tool arguments must be a JSON object"})
+        result = await bound.call(name, args)
+        return json.dumps(result)
+
+    return FunctionTool(
+        name=name,
+        description=schema.get("description") or name,
+        params_json_schema=params,
+        on_invoke_tool=_on_invoke,
+        strict_json_schema=False,
+    )
+
+
+def toolset_from_bound(bound: BoundTools) -> OpenAIAgentToolset:
+    return OpenAIAgentToolset([_function_tool(bound, s) for s in bound.schemas], bound)
+
+
+def load_tools(
+    *sources: str | Path | dict[str, Any],
+    env: Mapping[str, str] | None = None,
+    env_file: str | Path | None = None,
+) -> OpenAIAgentToolset:
+    """Compile tools.yaml into OpenAI Agents SDK ``FunctionTool``s."""
+    return connect(*sources, env=env, env_file=env_file).as_openai_agents()

vectorsmith/runtime.py

@@ -0,0 +1,139 @@
+"""Compile tools.yaml in-process. Framework adapters wrap this; MCP hosts use ``serve``."""
+
+from __future__ import annotations
+
+import os
+import uuid
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from vectorsmith_core.api import CallContext, EnvCredentialResolver, load_project
+from vectorsmith_core.execute.engine import Engine
+
+
+def _read_env_file(path: Path | None) -> dict[str, str]:
+    if path is None or not path.is_file():
+        return {}
+    out: dict[str, str] = {}
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        out[key.strip()] = value.strip()
+    return out
+
+
+def _merge_env(
+    env: Mapping[str, str] | None,
+    env_file: str | Path | None,
+) -> dict[str, str]:
+    merged = dict(os.environ)
+    if env:
+        merged.update(env)
+    merged.update(_read_env_file(Path(env_file) if env_file else None))
+    return merged
+
+
+def _one_engine(source: str | Path | dict[str, Any], env: Mapping[str, str]) -> Engine:
+    project = load_project(source, env=env)
+    errors = [i for i in project.issues if i.severity == "error"]
+    if errors:
+        msgs = "; ".join(f"{i.code} {i.message}" for i in errors)
+        raise ValueError(f"tools.yaml failed validation: {msgs}")
+    try:
+        from vectorsmith_core.embed.provider import FastEmbedProvider
+
+        embed: FastEmbedProvider | None = FastEmbedProvider()
+    except Exception:
+        embed = None
+    return Engine(
+        project,
+        credential_resolver=EnvCredentialResolver(env),
+        embed_provider=embed,
+    )
+
+
+class BoundTools:
+    """Compiled YAML tools. Call them directly, or adapt to an agent framework.
+
+    >>> from vectorsmith import connect
+    >>> vs = connect("tools.yaml")
+    >>> await vs.call("search_invoices", {"query": "Globex", "limit": 3})
+    >>> tools = vs.as_langchain()  # pip install 'vectorsmith[langchain]'
+    """
+
+    def __init__(self, engines: Sequence[Engine]) -> None:
+        self._engines = list(engines)
+        self._by_name: dict[str, Engine] = {}
+        schemas: list[dict[str, Any]] = []
+        for engine in self._engines:
+            for schema in engine.project.mcp_tool_schemas():
+                name = str(schema["name"])
+                self._by_name[name] = engine
+                schemas.append(schema)
+        self._schemas = schemas
+
+    @property
+    def names(self) -> list[str]:
+        return [str(s["name"]) for s in self._schemas]
+
+    @property
+    def schemas(self) -> list[dict[str, Any]]:
+        """MCP tool schemas (``name``, ``description``, ``inputSchema``)."""
+        return list(self._schemas)
+
+    def as_anthropic(self) -> list[dict[str, Any]]:
+        """Tool defs for ``anthropic.Anthropic().messages.create(tools=...)``."""
+        return [
+            {
+                "name": s["name"],
+                "description": s.get("description") or s["name"],
+                "input_schema": s.get("inputSchema") or {"type": "object", "properties": {}},
+            }
+            for s in self._schemas
+        ]
+
+    def as_langchain(self) -> Any:
+        """LangChain ``StructuredTool`` list. Requires ``vectorsmith[langchain]``."""
+        from vectorsmith.langchain_tools import toolset_from_bound
+
+        return toolset_from_bound(self)
+
+    def as_openai_agents(self) -> Any:
+        """OpenAI Agents SDK ``FunctionTool`` list. Requires ``vectorsmith[openai-agents]``."""
+        from vectorsmith.openai_agents import toolset_from_bound
+
+        return toolset_from_bound(self)
+
+    async def call(self, name: str, args: Mapping[str, Any] | None = None) -> dict[str, Any]:
+        engine = self._by_name.get(name)
+        if engine is None:
+            known = ", ".join(self.names) or "(none)"
+            raise KeyError(f"unknown tool {name!r}; loaded: {known}")
+        clean = {k: v for k, v in dict(args or {}).items() if v is not None}
+        result = await engine.call(
+            name, clean, ctx=CallContext(request_id=str(uuid.uuid4()))
+        )
+        return result.model_dump()
+
+    async def aclose(self) -> None:
+        for engine in self._engines:
+            await engine.aclose()
+
+
+def connect(
+    *sources: str | Path | dict[str, Any],
+    env: Mapping[str, str] | None = None,
+    env_file: str | Path | None = None,
+) -> BoundTools:
+    """Compile one or more tools.yaml files. No MCP subprocess.
+
+    Use this when you want ``await vs.call(...)`` or a non-LangChain adapter.
+    LangChain / LangGraph apps can keep using ``load_tools``.
+    """
+    if not sources:
+        raise ValueError("connect requires at least one tools.yaml path")
+    merged = _merge_env(env, env_file)
+    return BoundTools([_one_engine(source, merged) for source in sources])

vectorsmith-0.1.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.5
+Name: vectorsmith
+Version: 0.1.0
+Summary: YAML tools for agents: load_tools in-process, or vectorsmith serve as MCP
+Project-URL: Homepage, https://github.com/kjgpta/vectorsmith
+Project-URL: Documentation, https://kjgpta.github.io/vectorsmith/
+Project-URL: Issues, https://github.com/kjgpta/vectorsmith/issues
+Project-URL: Changelog, https://github.com/kjgpta/vectorsmith/blob/main/CHANGELOG.md
+Author: VectorSmith contributors
+License: Apache-2.0
+Keywords: agents,claude,codex,langchain,langgraph,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+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 :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: argon2-cffi
+Requires-Dist: httpx
+Requires-Dist: jsonschema
+Requires-Dist: lark
+Requires-Dist: mcp>=1.2
+Requires-Dist: polars>=1.0
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml
+Requires-Dist: ruamel-yaml
+Requires-Dist: starlette
+Requires-Dist: typer
+Requires-Dist: uvicorn
+Requires-Dist: watchfiles
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == 'anthropic'
+Provides-Extra: chroma
+Requires-Dist: chromadb>=0.5; extra == 'chroma'
+Requires-Dist: fastembed>=0.3; extra == 'chroma'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3; extra == 'langchain'
+Provides-Extra: langgraph
+Requires-Dist: langchain-core>=0.3; extra == 'langgraph'
+Requires-Dist: langgraph>=0.2; extra == 'langgraph'
+Provides-Extra: milvus
+Requires-Dist: fastembed>=0.3; extra == 'milvus'
+Requires-Dist: pymilvus>=2.4; extra == 'milvus'
+Provides-Extra: openai-agents
+Requires-Dist: openai-agents>=0.2; extra == 'openai-agents'
+Provides-Extra: pgvector
+Requires-Dist: fastembed>=0.3; extra == 'pgvector'
+Requires-Dist: psycopg[binary,pool]>=3.2; extra == 'pgvector'
+Provides-Extra: pinecone
+Requires-Dist: fastembed>=0.3; extra == 'pinecone'
+Requires-Dist: pinecone>=5.0; extra == 'pinecone'
+Provides-Extra: qdrant
+Requires-Dist: fastembed>=0.3; extra == 'qdrant'
+Requires-Dist: qdrant-client>=1.9; extra == 'qdrant'
+Provides-Extra: weaviate
+Requires-Dist: fastembed>=0.3; extra == 'weaviate'
+Requires-Dist: weaviate-client>=4.0; extra == 'weaviate'
+Description-Content-Type: text/markdown
+
+# vectorsmith
+
+Install this package. Write a `tools.yaml`. Use `load_tools` in Python or `vectorsmith serve` as an MCP server.
+
+```bash
+pip install "vectorsmith[qdrant,langchain]"
+```
+
+```python
+from vectorsmith import load_tools
+
+tools = load_tools("tools.yaml")
+```
+
+See the repository `README.md` and `docs/` for integrations and the YAML reference.

vectorsmith-0.1.0.dist-info/RECORD

@@ -0,0 +1,72 @@
+vectorsmith/__init__.py,sha256=GeKTiJgVlm_xdbyc90_y2Cbtwh8NciBQhOnxEzWo5gw,989
+vectorsmith/anthropic.py,sha256=rgU6MEwfOJQGUgozxsbowbdX-gFVjSe_BNLuGo0V87Q,1236
+vectorsmith/langchain.py,sha256=IuGzmEj8-ccCvXGKgqzETTeZExl6OzrpHvA8PLQ43M8,171
+vectorsmith/langchain_tools.py,sha256=JmzUaOeSehXn0CWM1AfneYbdnYOtBtn1hSodMUNx4Ng,3858
+vectorsmith/langgraph.py,sha256=n9UxPoOzubNMUrV7Avv6x8DSDiNABTKnmlXbbifWuX8,180
+vectorsmith/openai_agents.py,sha256=mCNypFVXY2svRut3WCsmsJhLMXORcsTqZyaFYOJJpgc,2147
+vectorsmith/runtime.py,sha256=54yMtGbm8VF7lLOLWO7by3ZDmmmkejunaTjG-R6u82Y,4858
+vectorsmith_cli/__init__.py,sha256=4HbPGNQQMJd5UZSftZH8clgTrAkSy9sBf2Ps5-z6SwA,23
+vectorsmith_cli/drafts_cmd.py,sha256=qqmsViVPShPIfihlk_4L9Dgdtg4uzIYKQ_pgwkfIiJY,2481
+vectorsmith_cli/identity.py,sha256=sIZpS8VnHWwWxbs3ce6Wb7RIToAyw6DBWU7WB4LD8Gc,147
+vectorsmith_cli/init_cmd.py,sha256=fK4G2z-qnvQr4anCL8XpfXr7JdXzfbHcOAsPtxSseJE,2430
+vectorsmith_cli/introspect_cmd.py,sha256=bDdyid3KtSylkruqXc6odUfkwDhhIqyKvM9j5KF4TcI,1179
+vectorsmith_cli/main.py,sha256=g2zDApzSKbyc13S14KDjRM5TPQAMCQ05caadoQUNl5g,5044
+vectorsmith_cli/serve_common.py,sha256=VlTeOQPxyhG13FPKjyZSmyBOvyOqQFeZacjuLd3QEqc,9570
+vectorsmith_cli/serve_http.py,sha256=0TLhHSnsnpCs7WMOOuNzmkssy5kpfWQMqVBqrQv1jZc,2225
+vectorsmith_cli/serve_stdio.py,sha256=UoT0_ELbeU1owru6ALFju5D1mdxHRNs-TMTgoJnaXr8,8060
+vectorsmith_cli/stdio_guard.py,sha256=k4HZ3-eH4Q1fNBPQjvZzjz9WQ1XUY9_LjaFaQltI3Ao,1081
+vectorsmith_cli/test_cmd.py,sha256=yyY1Wa4CBZRPJjcVd5ddvZVr8dD_meCro055A8xRJ94,2071
+vectorsmith_cli/validate_cmd.py,sha256=CiI7cuJ7NRgf2yliKx4v5aICRJgjbrTWkATRYw-nRvI,1953
+vectorsmith_cli/http/__init__.py,sha256=K4VECTV0gM_0BqseQl0mnHxN_DBOQ0xZWM48MRaP6E8,34
+vectorsmith_cli/http/app.py,sha256=9aLL2faH8IpLUpkYk7VnR8Qs9aphkwWjJW7F8v6zhq8,4956
+vectorsmith_cli/http/builtin_oauth/__init__.py,sha256=NkeW9Ge51z7U5HNCKa5Ge1hJbtChb_GN2eL_G28gWvM,54
+vectorsmith_cli/http/builtin_oauth/pages.py,sha256=oG-cY1y9jF7rE_Jxzsbg55kX-GGzMzjbZDf0y59Szss,623
+vectorsmith_cli/http/builtin_oauth/server.py,sha256=Erj0elNcHlHUPEFI0rGnaFCEmi0B_6mfzxa6Mi0JBrE,4231
+vectorsmith_cli/http/builtin_oauth/store.py,sha256=OYatIWltGBgC2WUiNVLdEx9KEbYKRBnk7CtdJgPUBWg,6332
+vectorsmith_core/__init__.py,sha256=SxAbEzTiHluRD3uTJ4S4ZvWyztL2AMKp0AiH86t3DDw,546
+vectorsmith_core/api.py,sha256=2yd8Lq98hVL4ifEKw2nT0YV5IYfGCSKf-IfiDYApkAc,6772
+vectorsmith_core/errors.py,sha256=tNRMI5Kh_GSDJwRF546SwPmx4x9NqP1PIKTZUVQe3m0,3223
+vectorsmith_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorsmith_core/version.py,sha256=OrrNqGg_HsnTK0acv_3MHDco0E48NrSrOobNBd71hHc,115
+vectorsmith_core/adapters/__init__.py,sha256=vZpumSKAd8Ri3D05x-B65LXqYp3SiBtQO3baOUkwOlQ,31
+vectorsmith_core/adapters/base.py,sha256=Ir9LgCWPA9fMRMwoLYnKQUw5QzjhH91ROnKsIrmm9zU,1644
+vectorsmith_core/adapters/capabilities.py,sha256=_hPdZi6ksvN57D1lWafNktEJuIsFyaNG2g_2Bc5Uozs,3026
+vectorsmith_core/adapters/chroma.py,sha256=DTkkctDo_266BDYthCE2bbsNeEC78G0CSxGte2FI5do,4624
+vectorsmith_core/adapters/milvus.py,sha256=thIxCzISHzxyNBpmJ0-k6ngDJt2nJTOpsEa2Bh35SqE,4632
+vectorsmith_core/adapters/pgvector.py,sha256=A3mPERVE6vMFjQvmNAZpn2o4id4MATNPbnlyHZiejSA,7825
+vectorsmith_core/adapters/pinecone.py,sha256=U9Poqi9inpdh87wtUPS_9pPSCy5t4d21KeGMn9RVSts,4098
+vectorsmith_core/adapters/qdrant.py,sha256=FFVIKR3hh9D0uALkVaVwNoBRX3upLUoZwbMdBsZGzGo,10033
+vectorsmith_core/adapters/registry.py,sha256=P65WmpWhHoGxtHDSa4Gyt3Bp_7TLl7ZdifBwkAVhBqg,24
+vectorsmith_core/adapters/weaviate.py,sha256=b-XYudeuDIRhbAabc80n4ODN3Qfb6-RWRMVICpuBa0M,4186
+vectorsmith_core/compilepkg/__init__.py,sha256=bQvhMh273TtK_2cIBAcWWjCptB3YtWIa68yMagXR0is,63
+vectorsmith_core/compilepkg/builtins.py,sha256=RSKp9Jc5MtXxr0Reg8PA0ZRpphcjDR3OomzxDxhqTB8,6083
+vectorsmith_core/compilepkg/compiler.py,sha256=0DrgSg5JKWFFSSCwo4IsSpMwTVkm1bJ8ttOKnDGFDTI,4961
+vectorsmith_core/compilepkg/drafts.py,sha256=dh8ait7s094p-tY-75Oyl_N4bqHpV8fpYgvD3zglDDQ,3976
+vectorsmith_core/compilepkg/validator.py,sha256=c74dv2jiJnT43nFalDGrYGgAmcb4msqSdUxIiJ6nVJI,10409
+vectorsmith_core/embed/__init__.py,sha256=1u-lJ4XYWAOVcS5pGX0MwrONrRiBftdmjYEBU7Fp6GE,27
+vectorsmith_core/embed/models.py,sha256=RIYvRKTbyA0XPiRLT4vuRTLHy-KYDRkhnxF4oAbin8U,189
+vectorsmith_core/embed/provider.py,sha256=JnJlQYpLaPful_Lli69kby22DtTcOrx1lclQUPWj3JQ,1959
+vectorsmith_core/execute/__init__.py,sha256=nx75OyqCrfT47SMucX58DoHldYreak8EqGcw0YWpNaE,50
+vectorsmith_core/execute/engine.py,sha256=gy1J-oWXq5eYoYz8HfTFp4gw3m3eGkxbpBdcI-YO-zE,8495
+vectorsmith_core/execute/pipeline.py,sha256=mjU_v049qRTevB7k749ziG_fztiq_rjvElwXd4NLRJc,4925
+vectorsmith_core/execute/single_step.py,sha256=zB23WBiDtrCJYb3UhGaXBEz8yd4iamV7ToHKP9WKOUQ,5190
+vectorsmith_core/execute/expr/__init__.py,sha256=YqW9tWRm0TfQTHzkjpkCtJ2aGsel11mKj12a0wazkVc,249
+vectorsmith_core/execute/expr/eval_polars.py,sha256=brOq2ZrWctEJiVt7zHwDxo3-ul52QBlJlUPkgW6g7wM,2908
+vectorsmith_core/execute/expr/grammar.lark,sha256=POsY9IcXiHdVu40uc-Z_Wb_bEEAOhs3-1P_-y_babK4,892
+vectorsmith_core/execute/expr/parser.py,sha256=KDpfIC6pn321r1Rr_qOjnVGgBOl8r-ecY6tv2bcWbes,3817
+vectorsmith_core/introspect/__init__.py,sha256=G48XnzpQNJkGTe6z1rHoVd69VklPRU9xKxRbYKJwcIc,62
+vectorsmith_core/introspect/sampling.py,sha256=0NzsIaDs_rbRC96fjyCHV_inevMwZKFJ3mMxihIjO8c,3493
+vectorsmith_core/introspect/schema_export.py,sha256=KN5UaVgxvu-fb-UOrispLsbQVzO4AGY62S-asYU3S7o,1993
+vectorsmith_core/introspect/schema_export_v1.json,sha256=R2jqepE4__T6WYPnjqOwKYdOSrSKCMCaS-hiF71bmqo,318
+vectorsmith_core/introspect/types.py,sha256=KC3QXowqmvM1qC6dGsZ_Ms6qMfMLKWeh2e2ty9sxxCg,34
+vectorsmith_core/ir/__init__.py,sha256=3Y2djgmDczH2Br6wDaRTLw_oT2j1ME6Ufrv0orQTVmI,42
+vectorsmith_core/ir/filter.py,sha256=26RTgP9JWY1DIHDa16Qmmi7SqRQljELoSaIrtf6JQjA,3006
+vectorsmith_core/tds/__init__.py,sha256=GOrUHuCCqT4weWSHxu8NrTreO3IA7Xr7AAUCBD-QRdg,52
+vectorsmith_core/tds/loader.py,sha256=QmaxxDr1ZCBo2EOO3asigMwABcMiczhZ3eF8z76E9mw,7012
+vectorsmith_core/tds/models.py,sha256=DMC7_3F3ZX_Xj_ixq85DgQx-qXuumkHB0dA893EVW6Y,7040
+vectorsmith_core/tds/schema.py,sha256=TOgQwY4HKf5PwfuWbjzUNfhu8xXFRGDofkF3qR4Tkr4,494
+vectorsmith_core/tds/schema_v1.json,sha256=gcJhKIgnpoFSW6Z5-JJM4Icw28rWDNytfCx-b6NJWIE,27368
+vectorsmith-0.1.0.dist-info/METADATA,sha256=pa_nSXV18CW26yQp_36f3ZOXRNqi43f0ue-uJATiMLA,2814
+vectorsmith-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+vectorsmith-0.1.0.dist-info/entry_points.txt,sha256=_XIsAsK3plnkfKB8dsnZueUEKjPEEzNyRmh2Mt2riGI,57
+vectorsmith-0.1.0.dist-info/RECORD,,

vectorsmith-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

vectorsmith-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vectorsmith = vectorsmith_cli.main:app

vectorsmith_cli/__init__.py

@@ -0,0 +1 @@
+"""VectorSmith CLI."""

vectorsmith_cli/drafts_cmd.py

@@ -0,0 +1,71 @@
+"""drafts list/reject and approve."""
+
+from __future__ import annotations
+
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+
+import yaml
+
+from vectorsmith_core.api import draft_tool, load_project, promote_draft
+
+
+def _drafts_path() -> Path:
+    return Path("tools.drafts.yaml")
+
+
+def run_drafts(action: str, name: str | None) -> None:
+    path = _drafts_path()
+    data = {"drafts": []}
+    if path.exists():
+        loaded = yaml.safe_load(path.read_text()) or {}
+        data["drafts"] = loaded.get("drafts") or []
+    if action == "list":
+        for d in data["drafts"]:
+            tool = d.get("tool") or {}
+            print(f"{d.get('status', 'pending'):10} {tool.get('name', '?')}", file=sys.stderr)
+        return
+    if action == "reject" and name:
+        for d in data["drafts"]:
+            if (d.get("tool") or {}).get("name") == name:
+                d["status"] = "rejected"
+        path.write_text(yaml.safe_dump(data, sort_keys=False))
+        print(f"rejected {name}", file=sys.stderr)
+        return
+    print("usage: drafts list | reject NAME", file=sys.stderr)
+    raise SystemExit(2)
+
+
+def run_approve(name: str, tools_file: Path) -> None:
+    path = _drafts_path()
+    if not path.exists():
+        print("no tools.drafts.yaml", file=sys.stderr)
+        raise SystemExit(2)
+    data = yaml.safe_load(path.read_text()) or {}
+    drafts = data.get("drafts") or []
+    match = next((d for d in drafts if (d.get("tool") or {}).get("name") == name), None)
+    if match is None:
+        print(f"draft {name} not found", file=sys.stderr)
+        raise SystemExit(2)
+    project = load_project(tools_file)
+    from vectorsmith_core.api import ToolDraft
+    from vectorsmith_core.tds.models import ToolSpec
+
+    spec = ToolSpec.model_validate(match["tool"])
+    draft = ToolDraft(spec=spec, validator_issues=[], provenance=match)
+    promoted = promote_draft(draft, project)
+    raw = yaml.safe_load(tools_file.read_text())
+    raw.setdefault("tools", []).append(promoted.model_dump(exclude_none=True))
+    header = (
+        f"# approved {datetime.now(UTC).isoformat()} "
+        f"hash={match.get('hash', '')}\n"
+    )
+    tools_file.write_text(header + yaml.safe_dump(raw, sort_keys=False))
+    match["status"] = "approved"
+    path.write_text(yaml.safe_dump(data, sort_keys=False))
+    print(f"Approved {name}. Toggle the connector in Claude to load it.", file=sys.stderr)
+
+
+# draft_tool imported for define_tool serve path
+_ = draft_tool

vectorsmith_cli/http/__init__.py

@@ -0,0 +1 @@
+"""HTTP app and builtin OAuth."""