End-User Connection Requirements

curl -X POST "https://api.getdynamiq.ai/v1/workflows/$WORKFLOW_ID/requirements" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DYNAMIQ_PAT" \
  -d '{
    "name": "openai",
    "type": "connection",
    "form": {
      "title": "OpenAI API Key",
      "description": "Used to run the assistant on your own OpenAI account."
    },
    "spec": {
      "type": "dynamiq.connections.OpenAI"
    }
  }'

curl -X POST "https://api.getdynamiq.ai/v1/workflows/$WORKFLOW_ID/requirements" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DYNAMIQ_PAT" \
  -d '{
    "name": "gmail",
    "type": "pipedream_account",
    "form": {
      "title": "Gmail Account",
      "description": "The agent sends email replies from this account."
    },
    "spec": {
      "app_slug": "gmail"
    }
  }'

# 1. Is user-42 ready to run the app?
curl "https://<your-app-hostname>/v1/requirements/status?user_id=user-42" \
  -H "Authorization: Bearer $DYNAMIQ_ACCESS_KEY"

# 2. Not yet ("status": "incomplete") - mint a 24h connect token
curl -X POST "https://<your-app-hostname>/v1/connect/tokens" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DYNAMIQ_ACCESS_KEY" \
  -d '{"user_id": "user-42"}'
# -> {"token": "<CONNECT_TOKEN>", "url": "...", "expires_at": "..."}

# 3. List what is pending, with specs
curl "https://api.getdynamiq.ai/v1/connect/requirements/status" \
  -H "Authorization: Bearer $CONNECT_TOKEN"

# 4a. Fulfill a connection requirement with credentials
curl -X POST "https://api.getdynamiq.ai/v1/connect/requirements/$REQUIREMENT_ID/credentials" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $CONNECT_TOKEN" \
  -d '{
    "type": "dynamiq.connections.OpenAI",
    "config": {"api_key": "<the end user'\''s key>"}
  }'

# 4b. Or get an authorization URL for an action connector account requirement
curl -X POST "https://api.getdynamiq.ai/v1/connect/requirements/$REQUIREMENT_ID/pipedream/authorize" \
  -H "Authorization: Bearer $CONNECT_TOKEN"
# -> {"data": {"url": "https://..."}}  open this URL for the user

# 5. Re-check, then run the app with the same user_id
curl "https://<your-app-hostname>/v1/requirements/status?user_id=user-42" \
  -H "Authorization: Bearer $DYNAMIQ_ACCESS_KEY"

import os
import requests

app_endpoint = "https://<your-app-hostname>"
api_base = "https://api.getdynamiq.ai"
end_user_id = "user-42"

app_headers = {"Authorization": f"Bearer {os.getenv('DYNAMIQ_ACCESS_KEY')}"}

# 1. Is the end user ready to run the app?
status = requests.get(
    f"{app_endpoint}/v1/requirements/status",
    params={"user_id": end_user_id},
    headers=app_headers,
).json()

if status["status"] == "completed":
    print("All requirements satisfied - run the app.")
else:
    print("Unsatisfied:", [r["form"]["title"] for r in status["unsatisfied"]])

    # 2. Mint a connect token (valid for 24 hours)
    token = requests.post(
        f"{app_endpoint}/v1/connect/tokens",
        json={"user_id": end_user_id},
        headers=app_headers,
    ).json()

    # Option A: hand off to the hosted connect page
    print("Hosted setup page:", token["url"])

    # Option B: fulfill programmatically with the connect token
    connect_headers = {"Authorization": f"Bearer {token['token']}"}
    requirements = requests.get(
        f"{api_base}/v1/connect/requirements/status",
        headers=connect_headers,
    ).json()["data"]

    for req in requirements:
        if req["status"] == "completed":
            continue

        if req["type"] == "connection":
            conn_type = req["spec"]["data"]["type"]
            if conn_type == "dynamiq.connections.OpenAI":
                # Non-OAuth connection: submit the user's credentials directly
                requests.post(
                    f"{api_base}/v1/connect/requirements/{req['id']}/credentials",
                    json={"type": conn_type, "config": {"api_key": os.getenv("END_USER_OPENAI_KEY")}},
                    headers=connect_headers,
                ).raise_for_status()
            else:
                # OAuth connection: redirect the user to the consent URL
                auth = requests.post(
                    f"{api_base}/v1/connect/requirements/{req['id']}/oauth2/authorize",
                    headers=connect_headers,
                ).json()
                print("Send the user to:", auth["data"]["url"])

        elif req["type"] == "pipedream_account":
            # Action connector account: open the hosted authorization URL
            auth = requests.post(
                f"{api_base}/v1/connect/requirements/{req['id']}/pipedream/authorize",
                headers=connect_headers,
            ).json()
            print("Send the user to:", auth["data"]["url"])

const appEndpoint = "https://<your-app-hostname>";
const apiBase = "https://api.getdynamiq.ai";
const endUserId = "user-42";

const appHeaders = {
  "Content-Type": "application/json",
  Authorization: `Bearer ${process.env.DYNAMIQ_ACCESS_KEY}`,
};

interface RequirementStatus {
  id: string;
  type: "connection" | "pipedream_account";
  title: string;
  status: "pending" | "completed";
  spec: { type: string; data: { type?: string; app_slug?: string } };
}

async function ensureRequirements() {
  // 1. Is the end user ready to run the app?
  const statusRes = await fetch(
    `${appEndpoint}/v1/requirements/status?user_id=${encodeURIComponent(endUserId)}`,
    { headers: appHeaders },
  );
  const status = await statusRes.json();

  if (status.status === "completed") {
    console.log("All requirements satisfied - run the app.");
    return;
  }

  // 2. Mint a connect token (valid for 24 hours)
  const tokenRes = await fetch(`${appEndpoint}/v1/connect/tokens`, {
    method: "POST",
    headers: appHeaders,
    body: JSON.stringify({ user_id: endUserId }),
  });
  const { token, url } = await tokenRes.json();

  // Option A: hand off to the hosted connect page
  console.log("Hosted setup page:", url);

  // Option B: fulfill programmatically with the connect token
  const connectHeaders = {
    "Content-Type": "application/json",
    Authorization: `Bearer ${token}`,
  };

  const reqsRes = await fetch(`${apiBase}/v1/connect/requirements/status`, {
    headers: connectHeaders,
  });
  const requirements: RequirementStatus[] = (await reqsRes.json()).data;

  for (const req of requirements) {
    if (req.status === "completed") continue;

    if (req.type === "connection" && req.spec.data.type === "dynamiq.connections.OpenAI") {
      // Non-OAuth connection: submit the user's credentials directly
      await fetch(`${apiBase}/v1/connect/requirements/${req.id}/credentials`, {
        method: "POST",
        headers: connectHeaders,
        body: JSON.stringify({
          type: req.spec.data.type,
          config: { api_key: process.env.END_USER_OPENAI_KEY },
        }),
      });
    } else if (req.type === "connection") {
      // OAuth connection: redirect the user to the consent URL
      const authRes = await fetch(
        `${apiBase}/v1/connect/requirements/${req.id}/oauth2/authorize`,
        { method: "POST", headers: connectHeaders },
      );
      console.log("Send the user to:", (await authRes.json()).data.url);
    } else {
      // Action connector account: open the hosted authorization URL
      const authRes = await fetch(
        `${apiBase}/v1/connect/requirements/${req.id}/pipedream/authorize`,
        { method: "POST", headers: connectHeaders },
      );
      console.log("Send the user to:", (await authRes.json()).data.url);
    }
  }
}

ensureRequirements();