Issue Dependencies

Issue dependencies express relationships between issues to track blocking, related, and duplicate connections in your project. Issue dependencies express relationships between issues to track blocking, related, and duplicate connections in your project.

from praisonaiagents import Agent

agent = Agent(name="planner", instructions="Link blocking dependencies between issues.")
agent.start("Mark ISS-10 blocked by ISS-7.")

The user links issues as blockers or related work so schedules reflect real delivery order.

Quick Start

Create a Dependency

Link one issue to another with a specific relationship type:

TOKEN="your-jwt-token"
WS_ID="workspace-id"
ISSUE_ID="issue-id"

curl -s -X POST http://localhost:8000/api/v1/workspaces/$WS_ID/issues/$ISSUE_ID/dependencies/ \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"depends_on_issue_id":"OTHER_ISSUE_ID","type":"blocks"}' \
  --max-time 10

List Dependencies

View all dependencies for an issue:

curl -s http://localhost:8000/api/v1/workspaces/$WS_ID/issues/$ISSUE_ID/dependencies/ \
  -H "Authorization: Bearer $TOKEN" \
  --max-time 10

Delete a Dependency

Remove a dependency by its ID:

curl -s -X DELETE http://localhost:8000/api/v1/workspaces/$WS_ID/issues/$ISSUE_ID/dependencies/DEP_ID \
  -H "Authorization: Bearer $TOKEN" \
  --max-time 10

How It Works

Dependencies are bidirectional - when you create a relationship between Issue A and Issue B, the dependency appears when listing from either issue.

Validation Rules

DELETE /workspaces/{ws}/issues/{issue_id}/dependencies/{dep_id} returns 404 Not Found if dep_id does not actually belong to issue_id (neither side of the relationship matches). This prevents deleting unrelated dependencies via URL manipulation.

Operation	Method	Purpose
Create	`POST`	Establish new dependency link
List	`GET`	View all dependencies for an issue
Delete	`DELETE`	Remove specific dependency

Configuration Options

All endpoints scope resources to the workspace in the URL path. Requesting an issue_id or dep_id that belongs to a different workspace returns 404 Not Found (never 200 or 403) to avoid leaking the existence of resources across tenants. The depends_on_issue_id is also validated against the URL workspace.

API Endpoints

Method	Endpoint	Description
`POST`	`/api/v1/workspaces/{ws_id}/issues/{issue_id}/dependencies/`	Create dependency
`GET`	`/api/v1/workspaces/{ws_id}/issues/{issue_id}/dependencies/`	List dependencies
`DELETE`	`/api/v1/workspaces/{ws_id}/issues/{issue_id}/dependencies/{dep_id}`	Delete dependency

Request Schema

Create Dependency:

{
  "depends_on_issue_id": "issue-def456",
  "type": "blocks"
}

Response:

{
  "id": "dep-abc123",
  "issue_id": "issue-abc123",
  "depends_on_issue_id": "issue-def456",
  "type": "blocks"
}

Dependency Types

Type	Meaning	Use Case
`blocks`	This issue blocks the other issue	Issue A must be resolved before Issue B can proceed
`related`	Issues are related but not blocking	Similar topics or shared components
`duplicates`	This issue is a duplicate of the other	Same problem reported multiple times

Common Patterns

Python with httpx
Bash Scripts
JavaScript Fetch

import asyncio
import httpx

async def main():
    base = "http://localhost:8000/api/v1"
    headers = {"Authorization": "Bearer YOUR_TOKEN", "Content-Type": "application/json"}
    ws_id = "your-workspace-id"

    async with httpx.AsyncClient() as client:
        # Create two issues first
        r1 = await client.post(f"{base}/workspaces/{ws_id}/issues/",
            json={"title": "Setup database"}, headers=headers)
        r2 = await client.post(f"{base}/workspaces/{ws_id}/issues/",
            json={"title": "Build API layer"}, headers=headers)
        issue1_id = r1.json()["id"]
        issue2_id = r2.json()["id"]

        # Issue 1 blocks Issue 2
        dep = await client.post(
            f"{base}/workspaces/{ws_id}/issues/{issue1_id}/dependencies/",
            json={"depends_on_issue_id": issue2_id, "type": "blocks"},
            headers=headers)
        print(dep.json())

        # List dependencies
        deps = await client.get(
            f"{base}/workspaces/{ws_id}/issues/{issue1_id}/dependencies/",
            headers=headers)
        print(deps.json())

asyncio.run(main())

#!/bin/bash

TOKEN="your-jwt-token"
WS_ID="workspace-id"
BASE_URL="http://localhost:8000/api/v1/workspaces/$WS_ID"

# Function to create dependency
create_dependency() {
    local from_issue=$1
    local to_issue=$2
    local type=$3
    
    curl -s -X POST "$BASE_URL/issues/$from_issue/dependencies/" \
      -H "Authorization: Bearer $TOKEN" \
      -H "Content-Type: application/json" \
      -d "{\"depends_on_issue_id\":\"$to_issue\",\"type\":\"$type\"}" \
      --max-time 10
}

# Function to list dependencies
list_dependencies() {
    local issue_id=$1
    
    curl -s "$BASE_URL/issues/$issue_id/dependencies/" \
      -H "Authorization: Bearer $TOKEN" \
      --max-time 10
}

# Usage examples
create_dependency "issue-123" "issue-456" "blocks"
list_dependencies "issue-123"

const BASE_URL = "http://localhost:8000/api/v1";
const TOKEN = "your-jwt-token";
const WS_ID = "workspace-id";

const headers = {
    "Authorization": `Bearer ${TOKEN}`,
    "Content-Type": "application/json"
};

// Create dependency
async function createDependency(fromIssueId, toIssueId, type) {
    const response = await fetch(
        `${BASE_URL}/workspaces/${WS_ID}/issues/${fromIssueId}/dependencies/`,
        {
            method: "POST",
            headers,
            body: JSON.stringify({
                depends_on_issue_id: toIssueId,
                type: type
            })
        }
    );
    return response.json();
}

// List dependencies
async function listDependencies(issueId) {
    const response = await fetch(
        `${BASE_URL}/workspaces/${WS_ID}/issues/${issueId}/dependencies/`,
        { headers }
    );
    return response.json();
}

// Usage
createDependency("issue-123", "issue-456", "blocks")
    .then(result => console.log("Created:", result));

Blocking Chain: Related Issues:

Best Practices

Use Clear Dependency Types

Choose the appropriate dependency type:

blocks: Use when one issue must be completed before another can start
related: Use for issues that share context but don’t block each other
duplicates: Use when multiple issues report the same problem

Avoid Circular Dependencies

While the API doesn’t prevent circular dependencies, avoid creating chains where Issue A blocks Issue B, and Issue B blocks Issue A. This creates deadlock situations in project planning.

Leverage Bidirectional Lookup

Dependencies appear when querying either issue in the relationship. Use this to discover related work when viewing any issue in your project.

Clean Up Resolved Dependencies

Delete dependencies when issues are resolved to keep the dependency graph clean and relevant for active work.

Dependency Deletion Security

The API guards against cross-issue dependency tampering by validating that dependency IDs actually belong to the issue in the URL before allowing deletion.

Testing

Run the dependency service tests to verify functionality:

pip install praisonai-platform[test]
pytest tests/test_new_gaps.py::TestDependencyService -v
pytest tests/test_new_api_integration.py::TestDependencyRoutes -v

Issue Management

Core issue creation and management

Workspace API

Workspace-level operations and access

Assign Work to AI Agents

Data Model

​Quick Start

​How It Works

​Validation Rules

​Configuration Options

​API Endpoints

​Request Schema

​Dependency Types

​Common Patterns

​Best Practices

​Testing

​Related

Issue Management

Workspace API

Quick Start

How It Works

Validation Rules

Configuration Options

API Endpoints

Request Schema

Dependency Types

Common Patterns

Best Practices

Testing

Related