@inkeep/agents-manage-api 0.1.1 → 0.1.6

package/dist/data/conversations.js

@@ -1,216 +0,0 @@
-import { nanoid } from 'nanoid';
-import dbClient from './db/dbClient.js';
-import { createMessage, getConversationHistory, } from '@inkeep/agents-core';
-/**
- * Creates default conversation history configuration
- * @param mode - The conversation history mode ('full' | 'scoped' | 'none')
- * @returns Default AgentConversationHistoryConfig
- */
-export function createDefaultConversationHistoryConfig(mode = 'full') {
-    return {
-        mode,
-        limit: 50,
-        includeInternal: true,
-        messageTypes: ['chat'],
-        maxOutputTokens: 4000,
-    };
-}
-/**
- * Extracts text content from A2A Message parts array
- */
-function extractA2AMessageText(parts) {
-    return parts
-        .filter((part) => part.kind === 'text' && part.text)
-        .map((part) => part.text)
-        .join('');
-}
-/**
- * Saves the result of an A2A client sendMessage call as a conversation message
- * @param response - The response from a2aClient.sendMessage()
- * @param params - Parameters for saving the message
- * @returns The saved message or null if no text content was found
- */
-export async function saveA2AMessageResponse(response, // SendMessageResponse type
-params) {
-    // Handle error responses
-    if (response.error) {
-        throw new Error(response.error.message);
-    }
-    // Extract text content based on result type
-    let messageText = '';
-    if (response.result.kind === 'message') {
-        // Handle Message type with parts array
-        messageText = extractA2AMessageText(response.result.parts);
-    }
-    else if (response.result.kind === 'task') {
-        // Handle Task type - extract text from artifacts if available
-        if (response.result.artifacts && response.result.artifacts.length > 0) {
-            const firstArtifact = response.result.artifacts[0];
-            if (firstArtifact.parts) {
-                messageText = extractA2AMessageText(firstArtifact.parts);
-            }
-        }
-    }
-    else if (typeof response.result === 'string') {
-        // Handle direct string responses (for backward compatibility)
-        messageText = response.result;
-    }
-    // Only save if we have meaningful text content
-    if (!messageText || messageText.trim() === '') {
-        return null;
-    }
-    // Save the message
-    return await createMessage(dbClient)({
-        id: nanoid(),
-        tenantId: params.tenantId,
-        projectId: params.projectId,
-        conversationId: params.conversationId,
-        role: 'agent',
-        content: {
-            text: messageText,
-        },
-        visibility: params.visibility,
-        messageType: params.messageType,
-        fromAgentId: params.fromAgentId,
-        toAgentId: params.toAgentId,
-        fromExternalAgentId: params.fromExternalAgentId,
-        toExternalAgentId: params.toExternalAgentId,
-        a2aTaskId: params.a2aTaskId,
-        a2aSessionId: params.a2aSessionId,
-        metadata: params.metadata,
-    });
-}
-/**
- * Applies filtering based on agent, task, or both criteria
- * Returns the filtered messages array
- */
-export async function getScopedHistory({ tenantId, projectId, conversationId, filters, options, }) {
-    try {
-        // Get conversation history with internal messages included
-        const messages = await getConversationHistory(dbClient)({
-            scopes: { tenantId, projectId },
-            conversationId,
-            options,
-        });
-        // If no filters provided, return all messages
-        if (!filters || (!filters.agentId && !filters.taskId)) {
-            return messages;
-        }
-        // Filter messages based on provided criteria
-        const relevantMessages = messages.filter((msg) => {
-            // Always include user messages
-            if (msg.role === 'user')
-                return true;
-            let matchesAgent = true;
-            let matchesTask = true;
-            // Apply agent filtering if agentId is provided
-            if (filters.agentId) {
-                matchesAgent =
-                    (msg.role === 'agent' && msg.visibility === 'user-facing') ||
-                        msg.toAgentId === filters.agentId ||
-                        msg.fromAgentId === filters.agentId;
-            }
-            // Apply task filtering if taskId is provided
-            if (filters.taskId) {
-                matchesTask = msg.taskId === filters.taskId || msg.a2aTaskId === filters.taskId;
-            }
-            // For combined filtering (both agent and task), both must match
-            // For single filtering, only the relevant one needs to match
-            if (filters.agentId && filters.taskId) {
-                return matchesAgent && matchesTask;
-            }
-            if (filters.agentId) {
-                return matchesAgent;
-            }
-            if (filters.taskId) {
-                return matchesTask;
-            }
-            return false;
-        });
-        return relevantMessages;
-    }
-    catch (error) {
-        console.error('Failed to fetch scoped messages:', error);
-        return [];
-    }
-}
-/**
- * Get user-facing conversation history (for client display)
- */
-export async function getUserFacingHistory(tenantId, projectId, conversationId, limit = 50) {
-    return await getConversationHistory(dbClient)({
-        scopes: { tenantId, projectId },
-        conversationId,
-        options: {
-            limit,
-            includeInternal: false,
-            messageTypes: ['chat'],
-        },
-    });
-}
-/**
- * Get full conversation context (for agent processing)
- */
-export async function getFullConversationContext(tenantId, projectId, conversationId, maxTokens) {
-    return await getConversationHistory(dbClient)({
-        scopes: { tenantId, projectId },
-        conversationId,
-        options: {
-            limit: 100,
-            includeInternal: true,
-            maxOutputTokens: maxTokens,
-        },
-    });
-}
-/**
- * Get formatted conversation history for a2a
- */
-export async function getFormattedConversationHistory({ tenantId, projectId, conversationId, currentMessage, options, filters, }) {
-    // Ensure includeInternal defaults to true for formatted history
-    const historyOptions = options ?? { includeInternal: true };
-    // Get filtered conversation history using unified function
-    const conversationHistory = await getScopedHistory({
-        tenantId,
-        projectId,
-        conversationId,
-        filters,
-        options: historyOptions,
-    });
-    // Filter out the current message if it's the most recent one
-    let messagesToFormat = conversationHistory;
-    if (currentMessage && conversationHistory.length > 0) {
-        const lastMessage = conversationHistory[conversationHistory.length - 1];
-        if (lastMessage.content.text === currentMessage) {
-            // Remove the last message if it matches the current prompt
-            messagesToFormat = conversationHistory.slice(0, -1);
-        }
-    }
-    if (!messagesToFormat.length) {
-        return '';
-    }
-    const formattedHistory = messagesToFormat
-        .map((msg) => {
-        let roleLabel;
-        if (msg.role === 'user') {
-            roleLabel = 'user';
-        }
-        else if (msg.role === 'agent' &&
-            (msg.messageType === 'a2a-request' || msg.messageType === 'a2a-response')) {
-            // For agent messages, include sender and recipient info when available
-            const fromAgent = msg.fromAgentId || msg.fromExternalAgentId || 'unknown';
-            const toAgent = msg.toAgentId || msg.toExternalAgentId || 'unknown';
-            roleLabel = `${fromAgent} to ${toAgent}`;
-        }
-        else if (msg.role === 'agent' && msg.messageType === 'chat') {
-            const fromAgent = msg.fromAgentId || 'unknown';
-            roleLabel = `${fromAgent} to User`;
-        }
-        else {
-            // System or other message types
-            roleLabel = msg.role || 'system';
-        }
-        return `${roleLabel}: """${msg.content.text}"""`; // TODO: add timestamp?
-    })
-        .join('\n');
-    return `<conversation_history>\n${formattedHistory}\n</conversation_history>\n`;
-}

package/dist/data/db/clean.d.ts

@@ -1,6 +0,0 @@
-/**
- * Truncates all tables in the database, respecting foreign key constraints
- * Tables are cleared in dependency order (child tables first, then parent tables)
- */
-export declare function cleanDatabase(): Promise<void>;
-//# sourceMappingURL=clean.d.ts.map

package/dist/data/db/clean.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["../../../src/data/db/clean.ts"],"names":[],"mappings":"AAwBA;;;GAGG;AACH,wBAAsB,aAAa,kBA6DlC"}

package/dist/data/db/clean.js

@@ -1,77 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { env } from '../../env.js';
-import { agentArtifactComponents, agentDataComponents, agentGraph, agentRelations, agents, agentToolRelations, artifactComponents, contextCache, contextConfigs, conversations, credentialReferences, dataComponents, externalAgents, ledgerArtifacts, messages, taskRelations, tasks, tools, } from '@inkeep/agents-core';
-import dbClient from './dbClient.js';
-/**
- * Truncates all tables in the database, respecting foreign key constraints
- * Tables are cleared in dependency order (child tables first, then parent tables)
- */
-export async function cleanDatabase() {
-    console.log(`🗑️  Cleaning database for environment: ${env.ENVIRONMENT}`);
-    console.log(`📁 Using database: ${env.DB_FILE_NAME}`);
-    console.log('---');
-    try {
-        // Disable foreign key constraints temporarily to make cleanup easier
-        await dbClient.run(sql `PRAGMA foreign_keys = OFF`);
-        // Order matters: clear dependent tables first
-        const tablesToClear = [
-            { table: messages, name: 'messages' },
-            { table: conversations, name: 'conversations' },
-            { table: taskRelations, name: 'task_relations' },
-            { table: tasks, name: 'tasks' },
-            { table: agentArtifactComponents, name: 'agent_artifact_components' },
-            { table: agentDataComponents, name: 'agent_data_components' },
-            { table: agentToolRelations, name: 'agent_tool_relations' },
-            { table: agentRelations, name: 'agent_relations' },
-            { table: agentGraph, name: 'agent_graph' },
-            { table: artifactComponents, name: 'artifact_components' },
-            { table: dataComponents, name: 'data_components' },
-            { table: tools, name: 'tools' },
-            { table: agents, name: 'agents' },
-            { table: externalAgents, name: 'external_agents' },
-            { table: ledgerArtifacts, name: 'ledger_artifacts' },
-            { table: credentialReferences, name: 'credential_references' },
-            { table: contextConfigs, name: 'context_configs' },
-            { table: contextCache, name: 'context_cache' },
-        ];
-        for (const { table, name } of tablesToClear) {
-            try {
-                await dbClient.delete(table).run();
-                console.log(`✅ Cleared table: ${name}`);
-            }
-            catch (error) {
-                // Handle case where table doesn't exist
-                const errorMessage = error?.message || '';
-                const causeMessage = error?.cause?.message || '';
-                if (errorMessage.includes('no such table') ||
-                    causeMessage.includes('no such table') ||
-                    (error?.cause?.code === 'SQLITE_ERROR' && causeMessage.includes('no such table'))) {
-                    console.log(`⚠️  Table ${name} doesn't exist, skipping`);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        // Re-enable foreign key constraints
-        await dbClient.run(sql `PRAGMA foreign_keys = ON`);
-        console.log('---');
-        console.log('🎉 Database cleaned successfully');
-    }
-    catch (error) {
-        console.error('❌ Failed to clean database:', error);
-        throw error;
-    }
-}
-// Run the clean function if executed directly
-if (import.meta.url === new URL(import.meta.url).href) {
-    cleanDatabase()
-        .then(() => {
-        console.log('Database cleanup completed');
-        process.exit(0);
-    })
-        .catch((error) => {
-        console.error('Database cleanup failed:', error);
-        process.exit(1);
-    });
-}

package/dist/data/db/dbClient.d.ts

@@ -1,3 +0,0 @@
-declare const dbClient: import("@inkeep/agents-core").DatabaseClient;
-export default dbClient;
-//# sourceMappingURL=dbClient.d.ts.map

package/dist/data/db/dbClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dbClient.d.ts","sourceRoot":"","sources":["../../../src/data/db/dbClient.ts"],"names":[],"mappings":"AAcA,QAAA,MAAM,QAAQ,8CAA4C,CAAC;AAC3D,eAAe,QAAQ,CAAC"}

package/dist/data/db/dbClient.js

@@ -1,13 +0,0 @@
-import { env } from '../../env.js';
-import { createDatabaseClient } from '@inkeep/agents-core';
-// Create database URL - use in-memory for tests, file for other environments
-const getDbUrl = () => {
-    // Use in-memory database for tests - each worker gets its own isolated database
-    if (env.ENVIRONMENT === 'test') {
-        return ':memory:';
-    }
-    return env.DB_FILE_NAME;
-};
-// Create the SQLite client
-const dbClient = createDatabaseClient({ url: getDbUrl() });
-export default dbClient;

package/dist/data/graphFull.d.ts

@@ -1,11 +0,0 @@
-import { type FullGraphDefinition } from '@inkeep/agents-core';
-/**
- * Client-side implementation of createFullGraph that makes HTTP requests to the API endpoint.
- * This function should be used by client code instead of directly accessing the data layer.
- */
-export declare const createFullGraph: (tenantId: string, graphData: FullGraphDefinition) => Promise<FullGraphDefinition>;
-/**
- * Client-side implementation of updateFullGraph that makes HTTP requests to the API endpoint.
- */
-export declare const updateFullGraph: (tenantId: string, graphId: string, graphData: FullGraphDefinition) => Promise<FullGraphDefinition>;
-//# sourceMappingURL=graphFull.d.ts.map

package/dist/data/graphFull.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphFull.d.ts","sourceRoot":"","sources":["../../src/data/graphFull.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,mBAAmB,EAA4B,MAAM,qBAAqB,CAAC;AAIzF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,WAAW,mBAAmB,KAC7B,OAAO,CAAC,mBAAmB,CAkD7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,SAAS,MAAM,EACf,WAAW,mBAAmB,KAC7B,OAAO,CAAC,mBAAmB,CAyD7B,CAAC"}

package/dist/data/graphFull.js

@@ -1,90 +0,0 @@
-import { env } from '../env.js';
-import { getLogger } from '../logger.js';
-import { validateAndTypeGraphData } from '@inkeep/agents-core';
-const logger = getLogger('graphFull');
-/**
- * Client-side implementation of createFullGraph that makes HTTP requests to the API endpoint.
- * This function should be used by client code instead of directly accessing the data layer.
- */
-export const createFullGraph = async (tenantId, graphData) => {
-    logger.info({
-        tenantId,
-        graphId: graphData.id,
-        agentCount: Object.keys(graphData.agents || {}).length,
-    }, 'Creating full graph via API endpoint');
-    try {
-        const baseUrl = env.AGENT_BASE_URL || `http://localhost:${env.PORT}`;
-        const endpoint = `${baseUrl}/tenants/${tenantId}/crud/graph`;
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(graphData),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`HTTP error ${response.status}: ${errorText}`);
-        }
-        const result = await response.json();
-        logger.info({
-            tenantId,
-            graphId: graphData.id,
-            status: response.status,
-        }, 'Full graph created successfully via API');
-        return result.data;
-    }
-    catch (error) {
-        logger.error({
-            tenantId,
-            graphId: graphData.id,
-            error: error instanceof Error ? error.message : 'Unknown error',
-        }, 'Failed to create full graph via API');
-        throw error;
-    }
-};
-/**
- * Client-side implementation of updateFullGraph that makes HTTP requests to the API endpoint.
- */
-export const updateFullGraph = async (tenantId, graphId, graphData) => {
-    const typed = validateAndTypeGraphData(graphData);
-    // Validate that the graphId matches the data.id
-    if (graphId !== typed.id) {
-        throw new Error(`Graph ID mismatch: expected ${graphId}, got ${typed.id}`);
-    }
-    logger.info({
-        tenantId,
-        graphId,
-        agentCount: Object.keys(graphData.agents || {}).length,
-    }, 'Updating full graph via API endpoint');
-    try {
-        const baseUrl = env.AGENT_BASE_URL || `http://localhost:${env.PORT}`;
-        const endpoint = `${baseUrl}/tenants/${tenantId}/crud/graph/${graphId}`;
-        const response = await fetch(endpoint, {
-            method: 'PUT',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(graphData),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`HTTP error ${response.status}: ${errorText}`);
-        }
-        const result = await response.json();
-        logger.info({
-            tenantId,
-            graphId,
-            status: response.status,
-        }, 'Full graph updated successfully via API');
-        return result.data;
-    }
-    catch (error) {
-        logger.error({
-            tenantId,
-            graphId,
-            error: error instanceof Error ? error.message : 'Unknown error',
-        }, 'Failed to update full graph via API');
-        throw error;
-    }
-};

package/dist/data/graphFullClient.d.ts

@@ -1,22 +0,0 @@
-/**
- * Client-side functions for interacting with the Full Graph API
- * These functions make HTTP requests to the server instead of direct database calls
- */
-import type { FullGraphDefinition } from '@inkeep/agents-core';
-/**
- * Create a full graph via HTTP API
- */
-export declare function createFullGraphViaAPI(tenantId: string, projectId: string, apiUrl: string, graphData: FullGraphDefinition): Promise<FullGraphDefinition>;
-/**
- * Update a full graph via HTTP API (upsert behavior)
- */
-export declare function updateFullGraphViaAPI(tenantId: string, projectId: string, apiUrl: string, graphId: string, graphData: FullGraphDefinition): Promise<FullGraphDefinition>;
-/**
- * Get a full graph via HTTP API
- */
-export declare function getFullGraphViaAPI(tenantId: string, projectId: string, apiUrl: string, graphId: string): Promise<FullGraphDefinition | null>;
-/**
- * Delete a full graph via HTTP API
- */
-export declare function deleteFullGraphViaAPI(tenantId: string, projectId: string, apiUrl: string, graphId: string): Promise<boolean>;
-//# sourceMappingURL=graphFullClient.d.ts.map

package/dist/data/graphFullClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graphFullClient.d.ts","sourceRoot":"","sources":["../../src/data/graphFullClient.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAI/D;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,mBAAmB,CAAC,CAyD9B;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,mBAAmB,CAAC,CAyD9B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CA4DrC;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CA0DlB"}

package/dist/data/graphFullClient.js

@@ -1,189 +0,0 @@
-/**
- * Client-side functions for interacting with the Full Graph API
- * These functions make HTTP requests to the server instead of direct database calls
- */
-import { getLogger } from '../logger.js';
-const logger = getLogger('graphFullClient');
-/**
- * Create a full graph via HTTP API
- */
-export async function createFullGraphViaAPI(tenantId, projectId, apiUrl, graphData) {
-    logger.info({
-        tenantId,
-        projectId,
-        graphId: graphData.id,
-        apiUrl,
-    }, 'Creating full graph via API');
-    const url = `${apiUrl}/tenants/${tenantId}/crud/projects/${projectId}/graph`;
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(graphData),
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        let errorMessage = `Failed to create graph: ${response.status} ${response.statusText}`;
-        try {
-            const errorJson = JSON.parse(errorText);
-            if (errorJson.error) {
-                errorMessage = errorJson.error;
-            }
-        }
-        catch {
-            // Use the text as-is if not JSON
-            if (errorText) {
-                errorMessage = errorText;
-            }
-        }
-        logger.error({
-            status: response.status,
-            error: errorMessage,
-        }, 'Failed to create graph via API');
-        throw new Error(errorMessage);
-    }
-    const result = await response.json();
-    logger.info({
-        graphId: graphData.id,
-    }, 'Successfully created graph via API');
-    return result.data;
-}
-/**
- * Update a full graph via HTTP API (upsert behavior)
- */
-export async function updateFullGraphViaAPI(tenantId, projectId, apiUrl, graphId, graphData) {
-    logger.info({
-        tenantId,
-        projectId,
-        graphId,
-        apiUrl,
-    }, 'Updating full graph via API');
-    const url = `${apiUrl}/tenants/${tenantId}/crud/projects/${projectId}/graph/${graphId}`;
-    const response = await fetch(url, {
-        method: 'PUT',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(graphData),
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        let errorMessage = `Failed to update graph: ${response.status} ${response.statusText}`;
-        try {
-            const errorJson = JSON.parse(errorText);
-            if (errorJson.error) {
-                errorMessage = errorJson.error;
-            }
-        }
-        catch {
-            // Use the text as-is if not JSON
-            if (errorText) {
-                errorMessage = errorText;
-            }
-        }
-        logger.error({
-            status: response.status,
-            error: errorMessage,
-        }, 'Failed to update graph via API');
-        throw new Error(errorMessage);
-    }
-    const result = await response.json();
-    logger.info({
-        graphId,
-    }, 'Successfully updated graph via API');
-    return result.data;
-}
-/**
- * Get a full graph via HTTP API
- */
-export async function getFullGraphViaAPI(tenantId, projectId, apiUrl, graphId) {
-    logger.info({
-        tenantId,
-        projectId,
-        graphId,
-        apiUrl,
-    }, 'Getting full graph via API');
-    const url = `${apiUrl}/tenants/${tenantId}/crud/projects/${projectId}/graph/${graphId}`;
-    const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-    });
-    if (response.status === 404) {
-        return null;
-    }
-    if (!response.ok) {
-        const errorText = await response.text();
-        let errorMessage = `Failed to get graph: ${response.status} ${response.statusText}`;
-        try {
-            const errorJson = JSON.parse(errorText);
-            if (errorJson.error) {
-                errorMessage = errorJson.error;
-            }
-        }
-        catch {
-            // Use the text as-is if not JSON
-            if (errorText) {
-                errorMessage = errorText;
-            }
-        }
-        logger.error({
-            status: response.status,
-            error: errorMessage,
-        }, 'Failed to get graph via API');
-        throw new Error(errorMessage);
-    }
-    const result = await response.json();
-    logger.info({
-        graphId,
-    }, 'Successfully retrieved graph via API');
-    return result.data;
-}
-/**
- * Delete a full graph via HTTP API
- */
-export async function deleteFullGraphViaAPI(tenantId, projectId, apiUrl, graphId) {
-    logger.info({
-        tenantId,
-        projectId,
-        graphId,
-        apiUrl,
-    }, 'Deleting full graph via API');
-    const url = `${apiUrl}/tenants/${tenantId}/crud/projects/${projectId}/graph/${graphId}`;
-    const response = await fetch(url, {
-        method: 'DELETE',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-    });
-    if (response.status === 404) {
-        return false;
-    }
-    if (!response.ok) {
-        const errorText = await response.text();
-        let errorMessage = `Failed to delete graph: ${response.status} ${response.statusText}`;
-        try {
-            const errorJson = JSON.parse(errorText);
-            if (errorJson.error) {
-                errorMessage = errorJson.error;
-            }
-        }
-        catch {
-            // Use the text as-is if not JSON
-            if (errorText) {
-                errorMessage = errorText;
-            }
-        }
-        logger.error({
-            status: response.status,
-            error: errorMessage,
-        }, 'Failed to delete graph via API');
-        throw new Error(errorMessage);
-    }
-    logger.info({
-        graphId,
-    }, 'Successfully deleted graph via API');
-    return true;
-}