stackshift-agent 0.1.0__py3-none-any.whl

stackshift_agent/__init__.py

@@ -0,0 +1,32 @@
+from .actions import Actions
+from .agent import AgentTool, StackShiftAgent, create_agent
+from .agreements import Agreements
+from .errors import ActionRefusedError, ActionWaitingError, PlatformCallError, StackShiftAgentError
+from .http import Response
+from .inbox import Inbox, address_of
+from .platform import Platform
+from .run import AgentEvent, ApprovalDecided
+from .state import Lock, State
+
+agent = create_agent()
+
+__all__ = [
+    "Actions",
+    "ActionRefusedError",
+    "ActionWaitingError",
+    "AgentEvent",
+    "AgentTool",
+    "ApprovalDecided",
+    "Agreements",
+    "Inbox",
+    "Lock",
+    "Platform",
+    "PlatformCallError",
+    "Response",
+    "StackShiftAgent",
+    "StackShiftAgentError",
+    "State",
+    "address_of",
+    "agent",
+    "create_agent",
+]

stackshift_agent/actions.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import functools
+import inspect
+import json
+import uuid
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable
+from urllib.parse import quote
+
+from .api import Api
+from .errors import ActionRefusedError, ActionWaitingError, StackShiftAgentError
+from .run import current_run
+from .state import State
+
+PENDING_SECONDS = 8 * 24 * 3600
+OUTPUT_LIMIT = 60_000
+SUMMARY_LIMIT = 240
+WAIT_SECONDS = 55
+
+
+@dataclass
+class Entry:
+    key: str
+    run: Callable[[Any], Any]
+
+
+class Actions:
+    def __init__(self, api: Api, state: State) -> None:
+        self._api = api
+        self._state = state
+        self._entries: dict[str, Entry] = {}
+
+    def register(self, key: str, run: Callable[[Any], Any], wait: bool = False) -> Callable[[Any], Awaitable[Any]]:
+        if key in self._entries:
+            raise StackShiftAgentError(f"The action {key} is already registered.", code="action_registered")
+        self._entries[key] = Entry(key, run)
+
+        async def admitted(args: Any = None) -> Any:
+            return await self._admit_and_run(key, args, wait)
+
+        return functools.wraps(run)(admitted)
+
+    def has(self, key: str) -> bool:
+        return key in self._entries
+
+    async def invoke(self, key: str, args: Any, wait: bool = False) -> Any:
+        if key not in self._entries:
+            raise StackShiftAgentError(f"There is no action {key} in this agent.", status=404, code="action_unknown")
+        return await self._admit_and_run(key, args, wait)
+
+    async def approved(self, admission_id: str, key: str, args: Any) -> bool:
+        parts = key.split(".")
+        entry = self._entries.get(".".join(parts[2:]) if parts[0] == "custom" and len(parts) >= 3 else key)
+        if entry is None:
+            return False
+        await self._state.delete(_pending_key(admission_id))
+        await self._execute(entry, admission_id, args)
+        return True
+
+    async def forget(self, admission_id: str) -> None:
+        await self._state.delete(_pending_key(admission_id))
+
+    async def _admit_and_run(self, key: str, args: Any, wait: bool) -> Any:
+        context = current_run.get()
+        if context is None:
+            raise StackShiftAgentError("Actions run while the agent handles an event.", code="no_run")
+        admission = await self._api.request(
+            "POST",
+            f"/agents/self/actions/{quote(key, safe='')}/admit",
+            {"run_id": context.run_id, "arguments": args if args is not None else {}, "correlation_id": str(uuid.uuid4())},
+        )
+        if admission["decision"] == "waiting" and wait:
+            admission = await self._api.request("GET", f"/agents/self/admissions/{admission['admission_id']}/wait", query={"seconds": WAIT_SECONDS}) or admission
+        if admission["decision"] == "refused":
+            raise ActionRefusedError(key, admission.get("reason", ""), admission.get("message", ""), admission.get("untrusted"))
+        if admission["decision"] == "waiting":
+            await self._state.set(
+                _pending_key(admission["admission_id"]),
+                {"key": key, "arguments": args, "admission_id": admission["admission_id"]},
+                ttl_seconds=PENDING_SECONDS,
+            )
+            context.waiting = True
+            raise ActionWaitingError(key, admission["admission_id"], admission.get("approval_id"), admission.get("message"))
+        return await self._execute(self._entries[key], admission["admission_id"], args)
+
+    async def _execute(self, entry: Entry, admission_id: str, args: Any) -> Any:
+        try:
+            result = entry.run(args)
+            if inspect.isawaitable(result):
+                result = await result
+        except Exception as failure:
+            await self._report(admission_id, "failed", str(failure), "")
+            raise
+        output = result if isinstance(result, str) else json.dumps(result)
+        await self._report(admission_id, "succeeded", output[:SUMMARY_LIMIT], output[:OUTPUT_LIMIT])
+        return result
+
+    async def _report(self, admission_id: str, status: str, summary: str, output: str) -> None:
+        await self._api.request("POST", f"/agents/self/admissions/{admission_id}/result", {"status": status, "summary": summary[:SUMMARY_LIMIT], "output": output})
+
+
+def _pending_key(admission_id: str) -> str:
+    return f"pending:{admission_id}"

stackshift_agent/adapters/claude.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..agent import StackShiftAgent
+from ..models import load
+
+
+async def claude_tools(agent: StackShiftAgent, *, server_name: str = "stackshift", sdk: Any = None) -> dict[str, Any]:
+    module = sdk or load("claude_agent_sdk", "Install claude-agent-sdk to use the Claude adapter.")
+    tools = await agent.tools()
+    definitions = []
+    for definition in tools:
+        definitions.append(_define(module, definition))
+    return {
+        "mcp_servers": {server_name: module.create_sdk_mcp_server(name=server_name, tools=definitions)},
+        "allowed_tools": [f"mcp__{server_name}__{definition.name}" for definition in tools],
+    }
+
+
+def _define(module: Any, definition: Any) -> Any:
+    async def handler(arguments: dict[str, Any]) -> dict[str, Any]:
+        return {"content": [{"type": "text", "text": await definition.execute(arguments)}]}
+
+    annotations = module.ToolAnnotations(readOnlyHint=definition.read_only)
+    return module.tool(definition.name, definition.description, definition.parameters, annotations=annotations)(handler)

stackshift_agent/adapters/openai_agents.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from ..agent import StackShiftAgent
+from ..models import load
+
+
+async def openai_tools(agent: StackShiftAgent, *, sdk: Any = None) -> list[Any]:
+    module = sdk or load("agents", "Install openai-agents to use the OpenAI Agents adapter.")
+    return [_define(module, definition) for definition in await agent.tools()]
+
+
+def _define(module: Any, definition: Any) -> Any:
+    async def invoke(_: Any, arguments: str) -> str:
+        return await definition.execute(json.loads(arguments) if arguments else {})
+
+    return module.FunctionTool(
+        name=definition.name,
+        description=definition.description,
+        params_json_schema=definition.parameters,
+        on_invoke_tool=invoke,
+        strict_json_schema=False,
+    )

stackshift_agent/agent.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import threading
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any, Awaitable, Callable, Mapping
+
+from .actions import Actions
+from .agreements import Agreements
+from .api import Api
+from .config import Config, resolve_config
+from .egress import fetch as egress_fetch
+from .errors import ActionWaitingError, StackShiftAgentError
+from .http import Response
+from .inbox import Inbox
+from .models import anthropic_client, openai_client
+from .platform import Platform
+from .run import AgentEvent, ApprovalDecided, RunContext, current_run
+from .state import State
+from .tokens import TokenStore
+from .verify import verify_delivery
+
+EVENT_PATH = "/stackshift/events"
+BODY_LIMIT = 4 << 20
+SEEN_LIMIT = 5000
+SEEN_SECONDS = 8 * 24 * 3600
+
+Handler = Callable[[AgentEvent], Any]
+
+
+@dataclass
+class AgentTool:
+    name: str
+    description: str
+    parameters: dict[str, Any]
+    read_only: bool
+    execute: Callable[[dict[str, Any]], Awaitable[str]]
+
+
+class StackShiftAgent:
+    def __init__(self, **options: Any) -> None:
+        self.config: Config = resolve_config(**options)
+        self._tokens = TokenStore(self.config.token_file)
+        self._api = Api(self.config, self._tokens)
+        self.state = State(self._api)
+        self.platform = Platform(self.config, self._tokens)
+        self._actions = Actions(self._api, self.state)
+        self.inbox = Inbox(self.platform, self.self_)
+        self.agreements = Agreements(self.platform, self.inbox.id)
+        self._handlers: dict[str, list[Handler]] = {}
+        self._seen: dict[str, None] = {}
+        self._running: set[str] = set()
+        self._guard = threading.Lock()
+        self._self: dict[str, Any] | None = None
+
+    def on(self, event: str, handler: Handler | None = None) -> Any:
+        def register(function: Handler) -> Handler:
+            self._handlers.setdefault(event, []).append(function)
+            return function
+
+        return register if handler is None else register(handler)
+
+    def action(self, key: str, run: Callable[[Any], Any] | None = None, *, wait: bool = False) -> Any:
+        if run is not None:
+            return self._actions.register(key, run, wait)
+        return lambda function: self._actions.register(key, function, wait)
+
+    async def self_(self) -> dict[str, Any]:
+        if self._self is None:
+            self._self = await self._api.request("GET", "/agents/self")
+        return self._self
+
+    async def tools(self) -> list[AgentTool]:
+        declared = (await self.self_())["actions"]
+        return [
+            AgentTool(
+                name=item["key"],
+                description=item["summary"],
+                parameters=item["input_schema"],
+                read_only=item["tier"] == "read",
+                execute=self._tool_runner(item["key"]),
+            )
+            for item in declared
+            if self._actions.has(item["key"])
+        ]
+
+    async def untrusted(self, text: str, source: str) -> str:
+        context = current_run.get()
+        if context is None:
+            raise StackShiftAgentError("Mark text as untrusted while the agent handles an event.", code="no_run")
+        await self._api.request("POST", "/agents/self/untrusted", {"run_id": context.run_id, "source": source, "text": text})
+        return text
+
+    async def fetch(self, url: str, *, method: str = "GET", headers: Mapping[str, str] | None = None, body: bytes | str | None = None) -> Response:
+        return await egress_fetch(self.config, url, method=method, headers=headers, body=body)
+
+    def anthropic(self) -> Any:
+        return anthropic_client(self.config, self._tokens, asynchronous=False)
+
+    def async_anthropic(self) -> Any:
+        return anthropic_client(self.config, self._tokens, asynchronous=True)
+
+    def openai(self) -> Any:
+        return openai_client(self.config, self._tokens, asynchronous=False)
+
+    def async_openai(self) -> Any:
+        return openai_client(self.config, self._tokens, asynchronous=True)
+
+    def serve(self) -> ThreadingHTTPServer:
+        if not self.config.event_key:
+            raise StackShiftAgentError("STACKSHIFT_EVENT_KEY is not set. StackShift sets it when the agent runs.", code="event_key_missing")
+        agent = self
+
+        class Events(BaseHTTPRequestHandler):
+            def do_GET(self) -> None:
+                self._send(200, {"ok": True}) if self.path == "/healthz" else self._send(404, {"error": "Not found."})
+
+            def do_POST(self) -> None:
+                if self.path != EVENT_PATH:
+                    return self._send(404, {"error": "Not found."})
+                length = int(self.headers.get("Content-Length") or 0)
+                if length > BODY_LIMIT:
+                    return self._send(413, {"error": "The event is too large."})
+                headers = {name.lower(): value for name, value in self.headers.items()}
+                try:
+                    status, body = asyncio.run(agent.deliver(headers, self.rfile.read(length)))
+                except Exception as failure:
+                    status, body = 500, {"error": str(failure)}
+                self._send(status, body)
+
+            def _send(self, status: int, body: dict[str, Any]) -> None:
+                payload = json.dumps(body).encode()
+                self.send_response(status)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(payload)))
+                self.end_headers()
+                self.wfile.write(payload)
+
+            def log_message(self, *_: Any) -> None:
+                return
+
+        return ThreadingHTTPServer(("", self.config.port), Events)
+
+    def start(self) -> None:
+        self.serve().serve_forever()
+
+    async def deliver(self, headers: Mapping[str, str], body: bytes) -> tuple[int, dict[str, Any]]:
+        if not verify_delivery(self.config.event_key, headers, body, self.config.now()):
+            return 401, {"error": "The event was not signed by StackShift."}
+        token = headers.get("x-stackshift-agent-token")
+        run_id = headers.get("x-stackshift-run")
+        event = _parse_event(body, run_id or "")
+        if not token or not run_id or event is None:
+            return 400, {"error": "The event is missing its token, run or body."}
+        with self._guard:
+            if event.id in self._seen:
+                return 200, {"outcome": "done"}
+            if event.id in self._running:
+                return 503, {"error": "This event is already running."}
+            self._running.add(event.id)
+        try:
+            await asyncio.to_thread(self._tokens.set, token)
+            return 200, await self._run(event)
+        finally:
+            with self._guard:
+                self._running.discard(event.id)
+
+    async def _run(self, event: AgentEvent) -> dict[str, Any]:
+        if await self._stored(event.id):
+            return {"outcome": "done"}
+        context = RunContext(run_id=event.run_id, event=event)
+        reset = current_run.set(context)
+        error: str | None = None
+        try:
+            await self._dispatch(event)
+            outcome = "waiting" if context.waiting else "done"
+        except ActionWaitingError:
+            outcome = "waiting"
+        except Exception as failure:
+            outcome, error = "failed", str(failure)
+        finally:
+            current_run.reset(reset)
+        if outcome != "failed":
+            await self._remember(event.id)
+        return {"outcome": outcome} if error is None else {"outcome": outcome, "error": error}
+
+    async def _dispatch(self, event: AgentEvent) -> None:
+        if event.type == "approval.decided":
+            data: ApprovalDecided = event.data
+            if data["decision"] == "approved":
+                await self._actions.approved(data["admission_id"], data["action_key"], data["arguments"])
+            else:
+                await self._actions.forget(data["admission_id"])
+        for handler in self._handlers.get(event.type, []):
+            result = handler(event)
+            if inspect.isawaitable(result):
+                await result
+
+    async def _stored(self, event_id: str) -> bool:
+        try:
+            return await self.state.get(f"event:{event_id}") is not None
+        except StackShiftAgentError:
+            return False
+
+    async def _remember(self, event_id: str) -> None:
+        with self._guard:
+            self._seen[event_id] = None
+            if len(self._seen) > SEEN_LIMIT:
+                del self._seen[next(iter(self._seen))]
+        try:
+            await self.state.set(f"event:{event_id}", True, ttl_seconds=SEEN_SECONDS)
+        except StackShiftAgentError:
+            return
+
+    def _tool_runner(self, key: str) -> Callable[[dict[str, Any]], Awaitable[str]]:
+        async def run(arguments: dict[str, Any]) -> str:
+            try:
+                result = await self._actions.invoke(key, arguments)
+            except ActionWaitingError:
+                return f"{key} needs the owner's approval. It is saved and runs once the owner approves. Stop working on this for now."
+            except StackShiftAgentError as failure:
+                return f"{key} was not done: {failure}"
+            return result if isinstance(result, str) else json.dumps(result)
+
+        return run
+
+
+def _parse_event(body: bytes, run_id: str) -> AgentEvent | None:
+    try:
+        parsed = json.loads(body)
+    except ValueError:
+        return None
+    if not isinstance(parsed, dict) or not parsed.get("event") or not parsed.get("id"):
+        return None
+    return AgentEvent(
+        type=parsed["event"],
+        id=parsed["id"],
+        agent=parsed.get("agent", ""),
+        at=parsed.get("at", ""),
+        data=parsed.get("data"),
+        untrusted=parsed.get("untrusted") or [],
+        run_id=run_id,
+    )
+
+
+def create_agent(**options: Any) -> StackShiftAgent:
+    return StackShiftAgent(**options)

stackshift_agent/agreements.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any, Awaitable, Callable
+
+from .platform import Platform
+
+
+class Agreements:
+    def __init__(self, platform: Platform, inbox_id: Callable[[], Awaitable[str]]) -> None:
+        self._platform = platform
+        self._inbox_id = inbox_id
+
+    async def list(self, **filters: Any) -> Any:
+        return await self._platform.inspect("agreements.list", filters)
+
+    async def inspect(self, thread_id: str) -> Any:
+        return await self._platform.inspect("agreements.inspect", {"thread_id": thread_id})
+
+    async def limits(self, inbox_id: str) -> Any:
+        return await self._platform.inspect("agreements.limits.inspect", {"inbox_id": inbox_id})
+
+    async def verify(self, record: dict[str, Any]) -> Any:
+        return await self._platform.inspect("agreements.verify", record)
+
+    async def wait(self, thread_id: str, after: str | None = None) -> Any:
+        return await self._platform.inspect("agreements.wait", {key: value for key, value in {"thread_id": thread_id, "after": after}.items() if value is not None})
+
+    async def propose(self, offer: dict[str, Any], **options: Any) -> dict[str, Any]:
+        return await self._platform.call("agreements.propose", {"inbox_id": await self._inbox_id(), **offer}, **options)
+
+    async def respond(self, thread_id: str, answer: dict[str, Any], **options: Any) -> dict[str, Any]:
+        return await self._platform.call("agreements.respond", {"thread_id": thread_id, **answer}, **options)
+
+    async def cancel(self, thread_id: str, details: dict[str, Any] | None = None, **options: Any) -> dict[str, Any]:
+        return await self._platform.call("agreements.cancel", {"thread_id": thread_id, **(details or {})}, **options)
+
+    async def count_reply(self, thread_id: str, offer_id: str, reply_message_id: str, **options: Any) -> dict[str, Any]:
+        return await self._platform.call("agreements.reply.count", {"thread_id": thread_id, "offer_id": offer_id, "reply_message_id": reply_message_id}, **options)

stackshift_agent/api.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+from urllib.parse import urlencode
+
+from .config import Config
+from .errors import StackShiftAgentError
+from .http import send
+from .tokens import TokenStore
+
+USER_AGENT = "stackshift-agent-python/0.1"
+
+
+class Api:
+    def __init__(self, config: Config, tokens: TokenStore) -> None:
+        self.config = config
+        self.tokens = tokens
+
+    async def request(self, method: str, path: str, body: Any = None, *, query: dict[str, Any] | None = None, allow_not_found: bool = False) -> Any:
+        params = {key: value for key, value in (query or {}).items() if value is not None}
+        suffix = f"?{urlencode(params)}" if params else ""
+        response = await send(
+            method,
+            f"{self.config.origin}/api/v1{path}{suffix}",
+            {
+                "Authorization": f"Bearer {self.tokens.current()}",
+                "Content-Type": "application/json",
+                "User-Agent": USER_AGENT,
+            },
+            None if body is None else json.dumps(body).encode(),
+        )
+        if response.status == 404 and allow_not_found:
+            return None
+        parsed = _parse(response.body)
+        if not response.ok:
+            failure = parsed.get("error") if isinstance(parsed, dict) else None
+            failure = failure if isinstance(failure, dict) else {}
+            raise StackShiftAgentError(
+                failure.get("message") or f"StackShift answered {response.status}.",
+                status=response.status,
+                code=failure.get("code"),
+            )
+        return parsed
+
+
+def _parse(body: bytes) -> Any:
+    if not body:
+        return None
+    try:
+        return json.loads(body)
+    except ValueError:
+        return None

stackshift_agent/config.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+import re
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Mapping
+
+DEFAULT_ORIGIN = "https://api.stackshift.cloud"
+
+
+@dataclass
+class Config:
+    origin: str
+    event_key: str
+    port: int
+    token_file: Path
+    anthropic_base_url: str
+    openai_base_url: str
+    secret_proxy_url: str
+    env: Mapping[str, str]
+    now: Callable[[], float] = field(default=time.time)
+
+
+def resolve_config(
+    *,
+    api_url: str | None = None,
+    event_key: str | None = None,
+    port: int | None = None,
+    token_file: str | os.PathLike[str] | None = None,
+    env: Mapping[str, str] | None = None,
+    now: Callable[[], float] | None = None,
+) -> Config:
+    values = os.environ if env is None else env
+    origin = re.sub(r"/api/v1$", "", (api_url or values.get("STACKSHIFT_API_URL") or DEFAULT_ORIGIN).rstrip("/"))
+    return Config(
+        origin=origin,
+        event_key=event_key or values.get("STACKSHIFT_EVENT_KEY", ""),
+        port=port if port is not None else int(values.get("PORT", "8080")),
+        token_file=Path(token_file) if token_file else Path.home() / ".stackshift" / "agent-token",
+        anthropic_base_url=values.get("ANTHROPIC_BASE_URL", f"{origin}/ai"),
+        openai_base_url=values.get("OPENAI_BASE_URL", f"{origin}/ai/v1"),
+        secret_proxy_url=values.get("STACKSHIFT_SECRET_PROXY_URL", "").rstrip("/"),
+        env=values,
+        now=now or time.time,
+    )

stackshift_agent/egress.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import re
+from typing import Mapping
+from urllib.parse import urlsplit
+
+from .config import Config
+from .http import Response, send
+
+PLACEHOLDER = re.compile(r"^stackshift-secret://([0-9a-f-]{36})/")
+
+
+def egress_key_env(host: str) -> str:
+    return "STACKSHIFT_EGRESS_KEY_" + re.sub(r"[^A-Za-z0-9]", "_", host).upper()
+
+
+async def fetch(config: Config, url: str, *, method: str = "GET", headers: Mapping[str, str] | None = None, body: bytes | str | None = None) -> Response:
+    payload = body.encode() if isinstance(body, str) else body
+    parts = urlsplit(url)
+    host = (parts.hostname or "").lower()
+    placeholder = config.env.get(egress_key_env(host), "")
+    match = PLACEHOLDER.match(placeholder)
+    if not match or not config.secret_proxy_url or parts.scheme != "https" or parts.port is not None:
+        return await send(method, url, headers, payload)
+    path = parts.path + (f"?{parts.query}" if parts.query else "")
+    return await send(
+        method,
+        f"{config.secret_proxy_url}/{match.group(1)}/{host}{path}",
+        {**(headers or {}), "X-Stackshift-Secret": placeholder},
+        payload,
+        follow_redirects=False,
+    )

stackshift_agent/errors.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class StackShiftAgentError(RuntimeError):
+    def __init__(self, message: str, *, status: int | None = None, code: str | None = None) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+
+
+class ActionRefusedError(StackShiftAgentError):
+    def __init__(self, action: str, reason: str, message: str, untrusted: dict[str, Any] | None = None) -> None:
+        super().__init__(message or f"StackShift refused {action}.", status=403, code=reason or "refused")
+        self.action = action
+        self.reason = reason
+        self.untrusted = untrusted
+
+
+class ActionWaitingError(StackShiftAgentError):
+    def __init__(self, action: str, admission_id: str, approval_id: str | None = None, message: str | None = None) -> None:
+        super().__init__(message or f"{action} is waiting for the owner's approval.", status=202, code="waiting")
+        self.action = action
+        self.admission_id = admission_id
+        self.approval_id = approval_id
+
+
+class PlatformCallError(StackShiftAgentError):
+    def __init__(self, key: str, message: str, details: Any = None) -> None:
+        super().__init__(message, code="platform_call_failed")
+        self.key = key
+        self.details = details

stackshift_agent/http.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+@dataclass
+class Response:
+    status: int
+    headers: Mapping[str, str]
+    body: bytes
+
+    @property
+    def ok(self) -> bool:
+        return 200 <= self.status < 300
+
+    def text(self) -> str:
+        return self.body.decode("utf-8", errors="replace")
+
+    def json(self) -> Any:
+        return json.loads(self.body) if self.body else None
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+
+def send_sync(method: str, url: str, headers: Mapping[str, str] | None = None, body: bytes | None = None, follow_redirects: bool = True, timeout: float = 120) -> Response:
+    request = urllib.request.Request(url, data=body, method=method, headers=dict(headers or {}))
+    opener = urllib.request.build_opener() if follow_redirects else urllib.request.build_opener(_NoRedirect())
+    try:
+        with opener.open(request, timeout=timeout) as reply:
+            return Response(reply.status, dict(reply.headers.items()), reply.read())
+    except urllib.error.HTTPError as failure:
+        return Response(failure.code, dict(failure.headers.items()), failure.read())
+
+
+async def send(method: str, url: str, headers: Mapping[str, str] | None = None, body: bytes | None = None, follow_redirects: bool = True, timeout: float = 120) -> Response:
+    return await asyncio.to_thread(send_sync, method, url, headers, body, follow_redirects, timeout)

stackshift_agent/inbox.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Awaitable, Callable
+
+from .errors import StackShiftAgentError
+from .platform import Platform
+
+
+class Inbox:
+    def __init__(self, platform: Platform, self_: Callable[[], Awaitable[dict[str, Any]]]) -> None:
+        self._platform = platform
+        self._self = self_
+
+    async def id(self) -> str:
+        inbox = (await self._self())["agent"].get("inbox_mailbox_id")
+        if not inbox:
+            raise StackShiftAgentError("This agent has no inbox. Add an inbox to the agent block in stackshift.yaml.", status=409, code="no_inbox")
+        return inbox
+
+    async def info(self) -> Any:
+        return await self._platform.inspect("mail.agent_inboxes.get", {"inbox_id": await self.id()})
+
+    async def send(
+        self,
+        *,
+        to: list[str],
+        subject: str,
+        text: str | None = None,
+        html: str | None = None,
+        cc: list[str] | None = None,
+        reply_to_message_id: str | None = None,
+        **options: Any,
+    ) -> dict[str, Any]:
+        configuration = {
+            "inbox_id": await self.id(),
+            "to": to,
+            "cc": cc,
+            "subject": subject,
+            "text": text,
+            "html": html,
+            "reply_to_message_id": reply_to_message_id,
+        }
+        return await self._platform.call("mail.agent_inbox.send", {key: value for key, value in configuration.items() if value is not None}, **options)
+
+    async def reply(self, message: dict[str, Any], text: str, **options: Any) -> dict[str, Any]:
+        subject = message["subject"]
+        return await self.send(
+            to=[address_of(message["from"])],
+            subject=subject if re.match(r"re:", subject, re.IGNORECASE) else f"Re: {subject}",
+            text=text,
+            reply_to_message_id=message["id"],
+            **options,
+        )
+
+
+def address_of(sender: str) -> str:
+    match = re.search(r"<([^>]+)>\s*$", sender)
+    return (match.group(1) if match else sender).strip()

stackshift_agent/models.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+from .config import Config
+from .errors import StackShiftAgentError
+from .tokens import TokenStore
+
+PLACEHOLDER_KEY = "stackshift-agent-token"
+
+
+def load(name: str, message: str) -> Any:
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        raise StackShiftAgentError(message, code="package_missing") from None
+
+
+def _stamp(tokens: TokenStore):
+    def apply(request: Any) -> None:
+        token = tokens.current()
+        request.headers["x-api-key"] = token
+        request.headers["Authorization"] = f"Bearer {token}"
+
+    return apply
+
+
+def _async_stamp(tokens: TokenStore):
+    stamp = _stamp(tokens)
+
+    async def apply(request: Any) -> None:
+        stamp(request)
+
+    return apply
+
+
+def anthropic_client(config: Config, tokens: TokenStore, *, asynchronous: bool) -> Any:
+    sdk = load("anthropic", "Install anthropic to use agent.anthropic().")
+    httpx = load("httpx", "Install httpx to use agent.anthropic().")
+    if asynchronous:
+        return sdk.AsyncAnthropic(api_key=PLACEHOLDER_KEY, base_url=config.anthropic_base_url, http_client=httpx.AsyncClient(event_hooks={"request": [_async_stamp(tokens)]}))
+    return sdk.Anthropic(api_key=PLACEHOLDER_KEY, base_url=config.anthropic_base_url, http_client=httpx.Client(event_hooks={"request": [_stamp(tokens)]}))
+
+
+def openai_client(config: Config, tokens: TokenStore, *, asynchronous: bool) -> Any:
+    sdk = load("openai", "Install openai to use agent.openai().")
+    httpx = load("httpx", "Install httpx to use agent.openai().")
+    if asynchronous:
+        return sdk.AsyncOpenAI(api_key=PLACEHOLDER_KEY, base_url=config.openai_base_url, http_client=httpx.AsyncClient(event_hooks={"request": [_async_stamp(tokens)]}))
+    return sdk.OpenAI(api_key=PLACEHOLDER_KEY, base_url=config.openai_base_url, http_client=httpx.Client(event_hooks={"request": [_stamp(tokens)]}))

stackshift_agent/platform.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import json
+import uuid
+from typing import Any
+
+from .config import Config
+from .errors import PlatformCallError, StackShiftAgentError
+from .http import send
+from .tokens import TokenStore
+
+UNSETTLED = {"waiting_approval", "queued", "running", "pending"}
+DEFAULT_WAIT_SECONDS = 55
+LONGEST_WAIT_SECONDS = 55
+
+
+class Platform:
+    def __init__(self, config: Config, tokens: TokenStore) -> None:
+        self._config = config
+        self._tokens = tokens
+        self._counter = 0
+
+    async def call(
+        self,
+        key: str,
+        configuration: dict[str, Any] | None = None,
+        *,
+        resource_id: str | None = None,
+        reason: str | None = None,
+        expected_resource_version: str | None = None,
+        idempotency_key: str | None = None,
+        wait: bool | int = True,
+    ) -> dict[str, Any]:
+        request = _strip({
+            "action": key,
+            "configuration": configuration or {},
+            "resource_id": resource_id,
+            "reason": reason,
+            "expected_resource_version": expected_resource_version,
+        })
+        proposed = await self._tool("operation_propose", {"request": request, "idempotency_key": idempotency_key or str(uuid.uuid4())}, key)
+        operation = _unwrap(proposed)
+        budget = 0 if wait is False else DEFAULT_WAIT_SECONDS if wait is True else int(wait)
+        deadline = self._config.now() + budget
+        while operation.get("state") in UNSETTLED and self._config.now() < deadline:
+            seconds = max(1, min(LONGEST_WAIT_SECONDS, int(deadline - self._config.now() + 0.999)))
+            waited = _unwrap(await self._tool("operation_wait", {"operationID": operation["id"], "timeout_seconds": seconds}, key))
+            operation = waited["operation"]
+            if waited.get("settled"):
+                break
+        return operation
+
+    async def inspect(self, key: str, configuration: dict[str, Any] | None = None, *, resource_id: str | None = None) -> Any:
+        answer = await self._tool("inspect", _strip({"action": key, "configuration": configuration or {}, "resource_id": resource_id}), key)
+        return _unwrap(answer)
+
+    async def _tool(self, name: str, arguments: dict[str, Any], key: str) -> Any:
+        is_error, text = await self._rpc(name, arguments)
+        value = _parse(text)
+        if is_error:
+            failure = value if isinstance(value, dict) else {}
+            nested = failure.get("error") if isinstance(failure.get("error"), dict) else {}
+            raise PlatformCallError(key, failure.get("message") or nested.get("message") or text or f"{key} was refused.", value)
+        return value
+
+    async def _rpc(self, name: str, arguments: dict[str, Any]) -> tuple[bool, str]:
+        self._counter += 1
+        response = await send(
+            "POST",
+            f"{self._config.origin}/api/v1/agents/mcp",
+            {
+                "Authorization": f"Bearer {self._tokens.current()}",
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+                "User-Agent": "stackshift-agent-python/0.1",
+            },
+            json.dumps({"jsonrpc": "2.0", "id": self._counter, "method": "tools/call", "params": {"name": name, "arguments": arguments}}).encode(),
+        )
+        raw = response.text()
+        if not response.ok:
+            failure = _parse(raw)
+            error = failure.get("error", {}) if isinstance(failure, dict) and isinstance(failure.get("error"), dict) else {}
+            raise StackShiftAgentError(error.get("message") or f"StackShift answered {response.status}.", status=response.status, code=error.get("code"))
+        envelope = _envelope(raw, response.headers.get("Content-Type", ""))
+        if envelope.get("error"):
+            raise StackShiftAgentError(envelope["error"].get("message") or "The call failed.", status=response.status, code=str(envelope["error"].get("code", "")))
+        result = envelope.get("result") or {}
+        text = "".join(part.get("text", "") for part in result.get("content", []) if part.get("type") == "text")
+        return result.get("isError") is True, text
+
+
+def _envelope(raw: str, content_type: str) -> dict[str, Any]:
+    if "text/event-stream" in content_type:
+        data = [line[5:].strip() for line in raw.split("\n") if line.startswith("data:") and line[5:].strip()]
+        parsed = _parse(data[-1]) if data else None
+    else:
+        parsed = _parse(raw)
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def _parse(text: str) -> Any:
+    try:
+        return json.loads(text)
+    except ValueError:
+        return text
+
+
+def _unwrap(value: Any) -> Any:
+    if isinstance(value, dict) and "success" in value and "data" in value:
+        return value["data"]
+    return value
+
+
+def _strip(values: dict[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in values.items() if value is not None}

stackshift_agent/run.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import contextvars
+from dataclasses import dataclass
+from typing import Any, Literal, TypedDict
+
+
+class _Decision(TypedDict):
+    admission_id: str
+    approval_id: str
+    action_key: str
+    decision: Literal["approved", "denied", "expired"]
+    arguments: Any
+
+
+class ApprovalDecided(_Decision, total=False):
+    note: str | None
+
+
+@dataclass
+class AgentEvent:
+    type: str
+    id: str
+    agent: str
+    at: str
+    data: Any
+    untrusted: list[str]
+    run_id: str
+
+
+@dataclass
+class RunContext:
+    run_id: str
+    event: AgentEvent
+    waiting: bool = False
+
+
+current_run: contextvars.ContextVar[RunContext | None] = contextvars.ContextVar("stackshift_agent_run", default=None)

stackshift_agent/state.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import uuid
+from contextlib import asynccontextmanager
+from datetime import datetime, timedelta, timezone
+from typing import Any, AsyncIterator
+from urllib.parse import quote
+
+from .api import Api
+from .errors import StackShiftAgentError
+
+
+class Lock:
+    def __init__(self, api: Api, key: str, owner: str) -> None:
+        self._api = api
+        self.key = key
+        self.owner = owner
+
+    async def release(self) -> None:
+        await self._api.request("DELETE", f"/agents/self/locks/{quote(self.key, safe='')}", {"owner": self.owner})
+
+
+class State:
+    def __init__(self, api: Api) -> None:
+        self._api = api
+
+    async def get(self, key: str) -> Any:
+        entry = await self._api.request("GET", f"/agents/self/state/{quote(key, safe='')}", allow_not_found=True)
+        return entry["value"] if entry else None
+
+    async def set(self, key: str, value: Any, *, ttl_seconds: int | None = None) -> None:
+        expires_at = None
+        if ttl_seconds is not None:
+            expires_at = (datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)).isoformat().replace("+00:00", "Z")
+        await self._api.request("PUT", f"/agents/self/state/{quote(key, safe='')}", {"value": value, "expires_at": expires_at})
+
+    async def delete(self, key: str) -> None:
+        await self._api.request("DELETE", f"/agents/self/state/{quote(key, safe='')}")
+
+    async def lock(self, key: str, *, ttl_seconds: int | None = None, owner: str | None = None) -> Lock | None:
+        holder = owner or str(uuid.uuid4())
+        answer = await self._api.request("POST", f"/agents/self/locks/{quote(key, safe='')}", {"owner": holder, "ttl_seconds": ttl_seconds})
+        if not answer or not answer.get("acquired"):
+            return None
+        return Lock(self._api, key, holder)
+
+    @asynccontextmanager
+    async def locked(self, key: str, *, ttl_seconds: int | None = None, owner: str | None = None) -> AsyncIterator[Lock]:
+        lock = await self.lock(key, ttl_seconds=ttl_seconds, owner=owner)
+        if lock is None:
+            raise StackShiftAgentError(f"Another run holds the lock {key}.", status=409, code="lock_held")
+        try:
+            yield lock
+        finally:
+            await lock.release()

stackshift_agent/tokens.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import os
+import threading
+from pathlib import Path
+
+from .errors import StackShiftAgentError
+
+
+class TokenStore:
+    def __init__(self, file: Path) -> None:
+        self._file = file
+        self._value = ""
+        self._lock = threading.Lock()
+
+    def set(self, token: str) -> None:
+        with self._lock:
+            self._value = token
+        try:
+            self._file.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+            descriptor = os.open(self._file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+            with os.fdopen(descriptor, "w") as handle:
+                handle.write(token)
+            os.chmod(self._file, 0o600)
+        except OSError:
+            return
+
+    def current(self) -> str:
+        with self._lock:
+            if self._value:
+                return self._value
+        try:
+            value = self._file.read_text().strip()
+        except OSError:
+            value = ""
+        if not value:
+            raise StackShiftAgentError(
+                "The agent has no run token yet. Calls to StackShift work while the agent handles an event.",
+                status=401,
+                code="token_missing",
+            )
+        with self._lock:
+            self._value = value
+        return value

stackshift_agent/verify.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import base64
+import binascii
+from typing import Mapping
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+MAX_AGE_SECONDS = 5 * 60
+MAX_SKEW_SECONDS = 60
+
+
+def verify_delivery(public_key: str, headers: Mapping[str, str], body: bytes, now: float) -> bool:
+    signature = headers.get("x-stackshift-signature")
+    timestamp = headers.get("x-stackshift-timestamp")
+    invocation = headers.get("x-stackshift-invocation")
+    if not signature or not timestamp or not invocation:
+        return False
+    try:
+        seconds = int(timestamp)
+        raw = base64.b64decode(public_key, validate=True)
+        signature_bytes = base64.b64decode(signature, validate=True)
+    except (ValueError, binascii.Error):
+        return False
+    age = now - seconds
+    if age > MAX_AGE_SECONDS or age < -MAX_SKEW_SECONDS or len(raw) != 32 or len(signature_bytes) != 64:
+        return False
+    try:
+        Ed25519PublicKey.from_public_bytes(raw).verify(signature_bytes, f"{timestamp}\n{invocation}\n".encode() + body)
+    except InvalidSignature:
+        return False
+    return True

stackshift_agent-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: stackshift-agent
+Version: 0.1.0
+Summary: Run an agent on StackShift: events, governed actions, StackShift calls, state and model access.
+Author-email: StackShift <support@stackshift.cloud>
+Project-URL: Homepage, https://stackshift.cloud
+Project-URL: Documentation, https://docs.stackshift.cloud
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=42
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.30; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.40; extra == "openai"
+Provides-Extra: claude-agent-sdk
+Requires-Dist: claude-agent-sdk>=0.1; extra == "claude-agent-sdk"
+Provides-Extra: openai-agents
+Requires-Dist: openai-agents>=0.1; extra == "openai-agents"
+
+# stackshift-agent
+
+Write an agent that runs on StackShift. The package receives the events that wake your agent, checks that StackShift sent them, runs your handlers, and gives your code the actions, StackShift calls, state and model access an agent needs.
+
+```bash
+pip install stackshift-agent
+```
+
+Python 3.9 or newer. The Anthropic and OpenAI clients and the two adapters use packages you install yourself (`anthropic`, `openai`, `claude-agent-sdk`, `openai-agents`). None of them is needed for the rest.
+
+## A first agent
+
+```python
+from stackshift_agent import agent
+
+
+@agent.action("lookup_order")
+async def lookup_order(args):
+    return {"order_id": args["order_id"], "status": "shipped"}
+
+
+@agent.on("inbox.message")
+async def answer(event):
+    order = await lookup_order({"order_id": event.data["message"]["subject"]})
+    await agent.inbox.reply(event.data["message"], f"Your order is {order['status']}.")
+
+
+agent.start()
+```
+
+`agent.start()` listens on `PORT` (8080 when it is not set) and answers `POST /stackshift/events`. Declare `lookup_order` in the `agent:` block of `stackshift.yaml`; StackShift only lets an action run if it is declared there.
+
+## Events
+
+`agent.on(event)` runs for each event of that name: `inbox.message`, `agreement.offer_received`, `agreement.agreed`, `agreement.declined`, `agreement.expired`, `agreement.waiting_for_you`, `a2a.message`, `schedule.tick`, `webhook.received`, `approval.decided` and `budget.warning`. The handler gets an object with `type`, `id`, `at`, `data`, `untrusted` and `run_id`. Handlers can be plain or `async` functions.
+
+Each event is checked against `STACKSHIFT_EVENT_KEY` (the Ed25519 signature on the delivery) before any handler runs. Events that arrive twice are dropped by their id. A handler that raises ends the run with the outcome `failed`; a run that saved an action for approval ends `waiting`; anything else ends `done`.
+
+## Actions and approvals
+
+`agent.action(key)` wraps your function. Each call asks StackShift first, with the arguments, and StackShift answers allowed, waiting or refused under the agent's level.
+
+- **Allowed:** your function runs and its result is recorded.
+- **Refused:** the call raises `ActionRefusedError` with a reason in plain words.
+- **Waiting:** by default the call is saved in the agent's state, the run ends with the outcome `waiting`, and when the owner decides the call runs again with exactly the arguments they approved. Pass `wait=True` to hold the run for up to 55 seconds instead.
+
+Mark text your agent fetched itself with `await agent.untrusted(text, "web:example.com")`. StackShift then asks before an action built from that text does anything that matters.
+
+## Calling StackShift
+
+```python
+operation = await agent.platform.call("database.inspect", {"database_id": database_id}, reason="Check the size")
+inbox = await agent.platform.inspect("mail.agent_inboxes.get", {"inbox_id": inbox_id})
+```
+
+`call` proposes the action through the agent's connection and waits up to 55 seconds for it to settle (`wait=False` returns at once). The agent can only use the actions its owner allowed. `inspect` runs a read.
+
+`agent.inbox` has `send`, `reply`, `info` and `id`. `agent.agreements` has `list`, `inspect`, `limits`, `verify`, `wait`, `propose`, `respond`, `cancel` and `count_reply`; they work when agreements are on for the agent's inbox.
+
+## State and locks
+
+```python
+await agent.state.set("last_report", {"at": 1}, ttl_seconds=86400)
+last = await agent.state.get("last_report")
+async with agent.state.locked("nightly"):
+    ...
+```
+
+## Models
+
+`agent.anthropic()` and `agent.openai()` return the official clients, already pointed at StackShift and signed in with the agent's run token; `agent.async_anthropic()` and `agent.async_openai()` return the async ones. There is no provider key in the agent. Pass `max_tokens` on every call.
+
+## Internet access
+
+`await agent.fetch(url, method="GET", headers=None, body=None)` returns a response with `status`, `headers`, `text()` and `json()`. For a host where the owner saved a key to send on the way out, the request goes through StackShift, which adds the key. The agent never holds it.
+
+## Claude Agent SDK and OpenAI Agents SDK
+
+```python
+from stackshift_agent.adapters.claude import claude_tools
+from stackshift_agent.adapters.openai_agents import openai_tools
+
+claude = await claude_tools(agent)
+tools = await openai_tools(agent)
+```
+
+`claude_tools` returns `mcp_servers` and `allowed_tools` for `ClaudeAgentOptions`. `openai_tools` returns `FunctionTool` objects for an `Agent`. Both turn your declared actions into tools with the approval step built in. A refusal or a wait comes back to the model as text, not as an error. Call them while handling an event.
+
+## What this does and does not enforce
+
+The wrapper governs your agent's model, which is what goes wrong in practice. It is not a guard against the developer: you own the code, so you can skip it. What StackShift enforces whatever the code does: model calls through StackShift, actions on StackShift, email and agreements, and which internet addresses the agent can reach.

stackshift_agent-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+stackshift_agent/__init__.py,sha256=nQCvZwXZBClW1pd2lUE7sT_hWNgqVaUZZShC9N07oU8,774
+stackshift_agent/actions.py,sha256=J1MuJVVeSn7nYKWz9gkuCPCBO6njnQsRjR9uuPMKxNY,4367
+stackshift_agent/agent.py,sha256=B6gk9sGjM74I5a3eoUPzSDgZxcW4B3bhoxpR4_lbLHY,10016
+stackshift_agent/agreements.py,sha256=ku0YAetNXwFZrWGE1eExlprpOouGbVwbZfHsyt9PdNU,2025
+stackshift_agent/api.py,sha256=z4M9BDRMvCsFa6csS1Vj58bW2JEUyjf-Sr9vB1cerZs,1778
+stackshift_agent/config.py,sha256=TO-RMO3sEWA6a2FyJObRPoEfgfoFG_lxYvj2ZBn-seQ,1498
+stackshift_agent/egress.py,sha256=ZYdLRCX37W006hxz_PI00Yh40JvcPLL8zuMndoBqIL4,1199
+stackshift_agent/errors.py,sha256=j3mzXOcMIM72xlgO8wEORE5m1ZIOi6WI3VDbALZvAxk,1295
+stackshift_agent/http.py,sha256=ZetlIwlF0Dx_gUvZDqAUxhxWxWyIQG4r3gwOy7Za1hQ,1607
+stackshift_agent/inbox.py,sha256=rSJ_6DLHiIKjk92zRNdkhGm8g6phAVNyCxLgd8XiKrI,2025
+stackshift_agent/models.py,sha256=Vmezk0BqlXbCOfn08Pby106B1keqB1HUImmmRv8wzp0,1943
+stackshift_agent/platform.py,sha256=95Zkuzv8ziEfDZcLq4sZi-kGLuHDOP5K896ElLJwZ6U,4954
+stackshift_agent/run.py,sha256=ylFEGZtn5cKCIKsvO6JvKdOi-FJYKmHr4avBCRgpqhU,723
+stackshift_agent/state.py,sha256=x1Ni5RssZKomAHA-fcU80jSYm1Ibc7EJGYLpxtgRudU,2262
+stackshift_agent/tokens.py,sha256=ip1sHKiW9DHCxQbCH7qECEXJF7V9GFJZL2_7FwL4b14,1295
+stackshift_agent/verify.py,sha256=Ppd3qs4diKSvIpv3xEshdgfw_0KtAwjKxaxmU1Jkbhg,1193
+stackshift_agent/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stackshift_agent/adapters/claude.py,sha256=MCLtCcIVUg6z-8KAyC-P8z6Qa5mpUSrfzNuXCprm8x4,1108
+stackshift_agent/adapters/openai_agents.py,sha256=oMyGq2388LXExO_EkJgGC_sn8WUZGDiykyaaV1K-daE,807
+stackshift_agent-0.1.0.dist-info/METADATA,sha256=2ilgTK3_MggIn9E-57L6vyaCPTAiqmCfBOc082FWR_w,5917
+stackshift_agent-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+stackshift_agent-0.1.0.dist-info/top_level.txt,sha256=kIVOwIFILP3aEfJHBGGk71B64l-rIq-Dg7IGiaXZTOI,17
+stackshift_agent-0.1.0.dist-info/RECORD,,

stackshift_agent-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stackshift_agent-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+stackshift_agent