Slopshop for
LangChain & LangGraph

# Wrap Slopshop tools as proper LangChain StructuredTool objects
# Auto-generates Pydantic schemas from /v1/openapi.json

import os, json, requests
from typing import Any
from langchain.tools import StructuredTool
from pydantic import BaseModel, create_model

SLOP_URL = "https://slopshop.gg"


def _make_args_schema(json_schema: dict) -> type[BaseModel]:
    """Build a Pydantic model from a JSON Schema dict."""
    fields = {}
    for name, prop in json_schema.get("properties", {}).items():
        py_type = {
            "string": str, "integer": int,
            "number": float, "boolean": bool
        }.get(prop.get("type", "string"), str)
        required = name in json_schema.get("required", [])
        fields[name] = (py_type, ...) if required else (py_type | None, None)
    return create_model("ArgsSchema", **fields)


def load_slopshop_tools(
    api_key: str,
    slugs: list[str] | None = None
) -> list[StructuredTool]:
    """
    Load Slopshop tools as LangChain StructuredTool objects.

    Args:
        api_key: Your Slopshop API key
        slugs: Tool slugs to load (None = load curated set from /v1/mcp/recommended)

    Returns:
        List of StructuredTool objects ready for use in any LangChain agent
    """
    headers = {"Authorization": f"Bearer {api_key}"}

    # Fetch tool manifest
    if slugs:
        url = f"{SLOP_URL}/v1/mcp/recommended?tools={','.join(slugs)}"
    else:
        url = f"{SLOP_URL}/v1/mcp/recommended"

    manifest = requests.get(url, headers=headers).json()
    tools = []

    for tool_def in manifest["tools"]:
        slug = tool_def["name"]
        schema = tool_def.get("input_schema", {})

        # Build the actual execution function (closure over slug + api_key)
        def make_fn(_slug, _key):
            def run(**kwargs: Any) -> str:
                resp = requests.post(
                    f"{SLOP_URL}/v1/{_slug}",
                    headers={
                        "Authorization": f"Bearer {_key}",
                        "Content-Type": "application/json"
                    },
                    json=kwargs
                )
                result = resp.json()
                return json.dumps(result)
            return run

        tools.append(StructuredTool(
            name=slug,
            description=tool_def["description"],
            func=make_fn(slug, api_key),
            args_schema=_make_args_schema(schema)
        ))

    return tools

# LangGraph ReAct agent using Slopshop tools
# Slopshop tools = standard LangChain tools, nothing special needed

import os
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

from slopshop_tools import load_slopshop_tools

SLOP_KEY = os.environ["SLOPSHOP_API_KEY"]

# Load the tools you want — or omit slugs for the curated recommended set
tools = load_slopshop_tools(SLOP_KEY, slugs=[
    "dns-lookup",
    "ssl-check",
    "http-request",
    "whois",
    "hash",
    "url-parse",
    "memory-set",
    "memory-get",
])

# Standard LangGraph ReAct agent — nothing Slopshop-specific here
llm   = ChatOpenAI(model="gpt-4o", temperature=0)
agent = create_react_agent(llm, tools)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": (
            "Audit github.com — check DNS records, SSL certificate grade, "
            "and HTTP security headers. Save a summary to memory."
        )
    }]
})

print(result["messages"][-1].content)

# Use Slopshop tools in an LCEL chain
# Or call /v1/pipe directly for server-side chaining

import os, requests
from langchain_core.runnables import RunnableLambda
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

SLOP_KEY = os.environ["SLOPSHOP_API_KEY"]
SLOP_URL = "https://slopshop.gg"
HDR = {"Authorization": f"Bearer {SLOP_KEY}", "Content-Type": "application/json"}


# Option A: Client-side LCEL chain using Slopshop RunnableLambdas
def slop_tool(slug: str):
    """Wrap a Slopshop tool as a LangChain Runnable."""
    def run(inputs: dict) -> dict:
        resp = requests.post(f"{SLOP_URL}/v1/{slug}", headers=HDR, json=inputs)
        return resp.json()
    return RunnableLambda(run)

# Build the chain with | operator — pure LCEL
security_chain = (
    slop_tool("dns-lookup")
    | RunnableLambda(lambda x: {"host": x.get("host", "input")})
    | slop_tool("ssl-check")
)

dns_result = security_chain.invoke({"host": "slopshop.gg"})
print(dns_result)


# Option B: Server-side pipe — single HTTP call, Slopshop chains for you
pipe_result = requests.post(
    f"{SLOP_URL}/v1/pipe",
    headers=HDR,
    json={
        "steps": [
            {"tool": "dns-lookup",   "input": {"host": "slopshop.gg"}},
            {"tool": "ssl-check",    "input": {"host": "$prev.host"}},
            {"tool": "http-request", "input": {"url": "https://slopshop.gg"}},
            {"tool": "memory-set",   "input": {"key": "audit:slopshop", "value": "$prev"}}
        ]
    }
).json()

print(pipe_result["results"])  # All 4 step results in one round-trip