Connections

from shipit_agent import Agent, connect, list_connectors

# Browse what ships:
for c in list_connectors():
    print(c.name, "·", c.category, "·", c.description)

# Attach one (hosted, per-user OAuth):
linear = connect("linear", token=user_token)
# …or a local one (stdio, env token):
slack  = connect("slack")

agent = Agent(llm=llm, mcps=[linear, slack])
agent.run("What Linear issues are assigned to me this cycle?")

from shipit_agent.connectors import list_connectors, connector_categories

connector_categories()                 # ['automation','business','communication',…]
list_connectors(category="developer")  # just the dev connectors

agent = Agent(
    llm=llm,
    mcps=[mgr.connect(c, user=user_id) for c in user_connectors],  # all 20
    deferred_tools=True,
)

# A question that needs nothing connected — nothing loads:
agent.run("Summarise the meeting notes I just pasted.")

# A question that needs Linear — the agent tool_searches and loads only Linear:
agent.run("What's assigned to me in Linear this cycle?")

from shipit_agent.connectors import OAuthCredentialManager, FileTokenStore

mgr = OAuthCredentialManager(FileTokenStore("/var/lib/shipit/tokens"))
mgr.register_preset(
    "linear",
    client_id=LINEAR_CLIENT_ID,
    client_secret=LINEAR_CLIENT_SECRET,
    redirect_uri="https://app.example.com/oauth/linear/callback",
)

# Send the user to connect:
url = mgr.authorize_url(user=user_id, connector="linear")
# …on the callback:
mgr.complete(connector="linear", code=code, state=state)

# Per turn, per user — token resolved + refreshed automatically:
agent = Agent(llm=llm, mcps=[mgr.connect("linear", user=user_id)])

# connectors/models.py
from django.conf import settings
from django.db import models

class ConnectorToken(models.Model):
    user      = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    connector = models.CharField(max_length=64, db_index=True)   # "linear", "slack"
    token     = models.JSONField(default=dict)   # access_token, refresh_token, expires_at
    updated   = models.DateTimeField(auto_now=True)
    class Meta:
        unique_together = ("user", "connector")

# connectors/stores.py
from django.core.cache import cache
from .models import ConnectorToken

class DjangoTokenStore:                       # satisfies TokenStore
    def get(self, user, connector):
        row = ConnectorToken.objects.filter(user_id=user, connector=connector).first()
        return dict(row.token) if row else None
    def set(self, user, connector, token):
        ConnectorToken.objects.update_or_create(
            user_id=user, connector=connector, defaults={"token": token})
    def delete(self, user, connector):
        ConnectorToken.objects.filter(user_id=user, connector=connector).delete()
    def connectors_for(self, user):
        return list(ConnectorToken.objects.filter(user_id=user)
                    .values_list("connector", flat=True))

class DjangoCacheStateStore:                  # satisfies OAuthStateStore (CSRF nonce)
    def save(self, state, payload): cache.set(f"oauth:{state}", payload, 600)
    def load(self, state):          return cache.get(f"oauth:{state}")
    def delete(self, state):        cache.delete(f"oauth:{state}")

# connectors/agent.py
from django.conf import settings
from shipit_agent.connectors import OAuthCredentialManager
from shipit_agent.integrations.oauth import OAUTH_PRESETS
from .stores import DjangoTokenStore, DjangoCacheStateStore

STATE = DjangoCacheStateStore()
manager = OAuthCredentialManager(DjangoTokenStore())

for name, cfg in settings.CONNECTOR_APPS.items():   # {"linear": {"client_id":…}, …}
    helper = OAUTH_PRESETS[cfg["provider"]](
        cfg["client_id"], cfg["client_secret"], cfg["redirect_uri"],
        scopes=cfg["scopes"], state_store=STATE,
    )
    manager.register(name, helper)

# connectors/views.py
from django.shortcuts import redirect
from rest_framework.decorators import api_view
from rest_framework.response import Response
from shipit_agent import Agent
from shipit_agent.connectors import NotConnected
from .agent import manager

@api_view(["GET"])
def connect(request, name):
    return redirect(manager.authorize_url(user=request.user.id, connector=name))

@api_view(["GET"])
def callback(request, name):
    manager.complete(connector=name, code=request.GET["code"], state=request.GET["state"])
    return redirect("/settings/connections")

@api_view(["GET"])
def connections(request):
    return Response(manager.connections(user=request.user.id))   # {connector: status}

@api_view(["POST"])
def ask(request):
    try:
        server = manager.connect("linear", user=request.user.id)   # token refreshed here
    except NotConnected:
        return Response({"connect": "/connectors/linear/connect"}, status=409)
    agent = Agent(llm=build_llm(), mcps=[server])
    return Response({"answer": agent.run(request.data["prompt"]).output})

from fastapi import FastAPI, Depends
from fastapi.responses import RedirectResponse
from shipit_agent import Agent
from shipit_agent.connectors import OAuthCredentialManager, InMemoryTokenStore, NotConnected
from shipit_agent.integrations.oauth import OAUTH_PRESETS

app = FastAPI()
manager = OAuthCredentialManager(InMemoryTokenStore())
manager.register("linear", OAUTH_PRESETS["linear"](/docs/guides/
    CLIENT_ID, CLIENT_SECRET, "https:/api.example.com/oauth/linear/callback",
    scopes=["read", "write"]))

@app.get("/connectors/{name}/connect")
def connect(name: str, user=Depends(current_user)):
    return RedirectResponse(manager.authorize_url(user=user.id, connector=name))

@app.get("/oauth/{name}/callback")
def callback(name: str, code: str, state: str):
    manager.complete(connector=name, code=code, state=state)
    return RedirectResponse("/settings/connections")

@app.get("/connections")
def connections(user=Depends(current_user)):
    return manager.connections(user=user.id)

@app.post("/ask")
def ask(prompt: str, user=Depends(current_user)):
    try:
        server = manager.connect("linear", user=user.id)
    except NotConnected:
        return {"connect": "/connectors/linear/connect"}
    return {"answer": Agent(llm=build_llm(), mcps=[server]).run(prompt).output}

from shipit_agent import FileOAuthStateStore, OAuthClientConfig, OAuthHelper

oauth = OAuthHelper(
    OAuthClientConfig(
        client_id="...",
        client_secret="...",
        redirect_uri="https://app.example.com/oauth/callback",
        scopes=["read", "write"],
        authorize_url="https://provider.example.com/oauth/authorize",
        token_url="https://provider.example.com/oauth/token",
    ),
    state_store=FileOAuthStateStore(".shipit/oauth-state.json"),
)

# 1. Send the user to the provider. The state is a one-time nonce, saved with your payload.
start = oauth.create_authorization_url(state_payload={"user_id": "u_812"})
redirect_to(start["url"])

# 2. On the callback, exchange the code. Passing the state checks it against the saved nonce.
tokens = oauth.exchange_code(code=request.args["code"], state=request.args["state"])

# 3. Later, renew an expired access token.
tokens = oauth.refresh_token(tokens["refresh_token"])

manifest_version: 1
name: linear
description: Linear issues, cycles, projects and comments.
category: developer
icon: "📐"
transport: {type: http, url: https://mcp.linear.app/sse}
auth: {type: oauth, provider: linear, scopes: [read, write]}
suggest: {keywords: [linear, issue, ticket]}