@aiconnect/agentjobs-mcp 1.0.8 → 1.0.9

package/README.md

@@ -153,9 +153,9 @@ This MCP server is designed to work out-of-the-box with minimal configuration. I
 - `AICONNECT_API_KEY`: `""` (empty - you must provide this)
 
 **Error Handling:**
-- If `AICONNECT_API_KEY` is not provided, tools will return helpful error messages
-- If `AICONNECT_API_URL` is not set, it defaults to the production API
-- If `DEFAULT_ORG_ID` is not set, it defaults to "aiconnect"
+- The server will always start, even if environment variables are missing.
+- If `AICONNECT_API_KEY` or `AICONNECT_API_URL` are not provided, each tool will return a clear error message upon execution, guiding the user to configure the environment correctly.
+- If `DEFAULT_ORG_ID` is not set, it defaults to "aiconnect".
 
 ### Running the MCP server
 
@@ -260,11 +260,13 @@ Agent: "Cancel job job-456 because it's no longer needed"
 ```
 agentjobs-mcp/
 ├── src/                    # TypeScript source code
-│   ├── index.ts           # Main MCP server
-│   ├── cancel_job.ts      # Tool for canceling jobs
-│   ├── create_job.ts      # Tool for creating jobs
-│   ├── get_job.ts         # Tool for querying job
-│   └── list_jobs.ts       # Tool for listing jobs
+│   ├── index.ts           # Main MCP server entry point
+│   ├── config.ts          # Configuration loader
+│   └── tools/             # Directory for all MCP tools
+│       ├── list_jobs.ts   # Tool for listing jobs
+│       ├── get_job.ts     # Tool for getting a job
+│       ├── create_job.ts  # Tool for creating a job
+│       └── cancel_job.ts  # Tool for canceling a job
 ├── build/                 # Compiled JavaScript code
 ├── docs/                  # Documentation
 │   └── agent-jobs-api.md  # API documentation
@@ -283,10 +285,11 @@ agentjobs-mcp/
 
 ### Adding new tools
 
-1. Create a new file in the `src/` folder (e.g., `new_tool.ts`)
-2. Implement the tool following the pattern of existing files
-3. Register the tool in `src/index.ts`
-4. Recompile with `npm run build`
+Adding a new tool is simple:
+
+1. Create a new TypeScript file inside the `src/tools/` directory (e.g., `my_new_tool.ts`).
+2. Implement your tool logic following the existing pattern. The server will automatically detect and register it on startup.
+3. Recompile the project with `npm run build`.
 
 ## Contributing
 

package/build/index.js

@@ -3,10 +3,9 @@ import * as dotenv from 'dotenv';
 dotenv.config();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import cancel_job from "./cancel_job.js";
-import get_job from "./get_job.js";
-import list_jobs from "./list_jobs.js";
-import create_job from "./create_job.js";
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
 // Get package version
 const packageJson = JSON.parse(await import('fs').then(fs => fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8')));
 // CLI argument parsing
@@ -55,27 +54,30 @@ if (args.includes('--config') || args.includes('-c')) {
     console.log(`  MCP Server Version: ${packageJson.version}`);
     process.exit(0);
 }
-// Validate required environment variables
-if (!process.env.AICONNECT_API_URL) {
-    console.error('Error: AICONNECT_API_URL environment variable is required');
-    console.error('Use --help for more information');
-    process.exit(1);
-}
-if (!process.env.AICONNECT_API_KEY) {
-    console.error('Error: AICONNECT_API_KEY environment variable is required');
-    console.error('Use --help for more information');
-    process.exit(1);
-}
 // Initialize server
 const server = new McpServer({
     name: "agentjobs-mcp",
     version: packageJson.version
 });
-// Initialize components
-cancel_job(server);
-get_job(server);
-list_jobs(server);
-create_job(server);
+// Dynamically load and register tools
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const toolsDir = path.join(__dirname, 'tools');
+try {
+    const toolFiles = await fs.readdir(toolsDir);
+    for (const file of toolFiles) {
+        if (file.endsWith('.js')) { // In production, files will be .js
+            const toolModule = await import(`./tools/${file}`);
+            if (typeof toolModule.default === 'function') {
+                toolModule.default(server);
+                console.error(`-> Registered tool: ${file}`);
+            }
+        }
+    }
+}
+catch (error) {
+    console.error("Error loading tools:", error);
+    process.exit(1);
+}
 // Start server with stdio transport
 const transport = new StdioServerTransport();
 console.error(`Starting AI Connect Agent Jobs MCP Server v${packageJson.version}...`);

package/build/{cancel_job.js → tools/cancel_job.js}

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import axios from 'axios';
-import { config } from './config.js';
+import { config } from '../config.js';
+import { formatJobSummary } from '../utils/formatters.js';
 export default (server) => {
     server.tool("cancel_job", "Cancels an agent job by its ID.", {
         job_id: z.string({
-            description: "The ID of the job to cancel.",
+            description: "The unique identifier of the job to be canceled. Example: 'job-12345'.",
         }),
-        reason: z.string().optional().describe("Optional reason for cancellation."),
+        reason: z.string().optional().describe("An optional reason explaining why the job is being canceled."),
     }, async (params) => {
         const { job_id, reason } = params;
         const apiUrl = config.AICONNECT_API_URL;
@@ -41,21 +42,25 @@ export default (server) => {
                 headers,
                 data: requestBody, // axios uses 'data' for DELETE request body
             });
-            // Assuming the API returns a message field on success as per docs/agent-jobs-api.md:229
-            const responseMessage = response.data?.message || `Job with ID '${job_id}' successfully canceled.`;
+            const canceledJob = response.data?.data || { job_id, job_status: 'canceled' };
+            const summary = formatJobSummary(canceledJob);
             return {
                 content: [{
                         type: "text",
-                        text: responseMessage,
+                        text: `Successfully canceled job:\n\n${summary}`,
                     }]
             };
         }
         catch (error) {
             let errorMessage = `Failed to cancel job ${job_id}.`;
+            let errorDetails = {};
             if (axios.isAxiosError(error) && error.response) {
-                // Try to get a more specific error message from the API response
                 const apiError = error.response.data?.message || error.response.data?.error || JSON.stringify(error.response.data);
                 errorMessage = `API Error (${error.response.status}): ${apiError || error.message}`;
+                errorDetails = {
+                    status: error.response.status,
+                    data: error.response.data
+                };
             }
             else if (error instanceof Error) {
                 errorMessage = `Error: ${error.message}`;
@@ -64,7 +69,7 @@ export default (server) => {
                 content: [{
                         type: "text",
                         text: errorMessage,
-                    }]
+                    }],
             };
         }
     });

package/build/tools/create_job.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import axios from 'axios';
+import { config } from '../config.js';
+/**
+ * Lightweight Agent‑Jobs creator.
+ * Only the essentials are required to keep the contract LLM‑friendly.
+ */
+export default (server) => {
+    server.tool('create_job', 'Create a new Agent Job with the minimal set of fields.', {
+        // ─────────────────────────────────────────────────────────────────────────┐
+        // Required
+        // ─────────────────────────────────────────────────────────────────────────┘
+        job_type_id: z
+            .string()
+            .describe('ID of the job type (e.g. "mood-monitor")'),
+        target_channel: z
+            .object({
+            platform: z
+                .enum(['whatsapp', 'slack', 'web'])
+                .describe('Destination platform.'),
+            code: z
+                .string()
+                .describe('Channel identifier, phone number, or user ID.'),
+            org_id: z
+                .string()
+                .optional()
+                .describe('Org ID – defaults to config.DEFAULT_ORG_ID')
+        })
+            .describe('Where the agent will communicate.'),
+        params: z
+            .record(z.any())
+            .optional()
+            .describe('Free‑form params passed to the agent'),
+        scheduled_at: z
+            .string()
+            .datetime({ message: 'Use ISO‑8601' })
+            .optional()
+            .describe('Schedule the job to run later')
+    }, 
+    // ───────────────────────────────────────────────────────────────────────────┐
+    // Implementation                                                             │
+    // ───────────────────────────────────────────────────────────────────────────┘
+    async (params) => {
+        const { AICONNECT_API_URL: apiUrl, AICONNECT_API_KEY: apiKey, DEFAULT_ORG_ID } = config;
+        if (!apiUrl) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Error: API URL is not configured. Please set AICONNECT_API_URL environment variable."
+                    }]
+            };
+        }
+        if (!apiKey) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Error: API Key is not configured. Please set AICONNECT_API_KEY environment variable."
+                    }]
+            };
+        }
+        // Fall back to default org if none supplied.
+        params.target_channel.org_id ??= DEFAULT_ORG_ID;
+        try {
+            const res = await axios.post(`${apiUrl}/services/agent-jobs`, params, {
+                headers: { Authorization: `Bearer ${apiKey}` }
+            });
+            const jobId = res.data?.data?.id ?? res.data?.id ?? 'unknown';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Job created (id: ${jobId}).`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            let errorMessage = `Failed to create job.`;
+            if (axios.isAxiosError(error) && error.response) {
+                const apiError = error.response.data?.message || error.response.data?.error || JSON.stringify(error.response.data);
+                errorMessage = `API Error (${error.response.status}): ${apiError || error.message}`;
+            }
+            else if (error instanceof Error) {
+                errorMessage = `Error: ${error.message}`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: errorMessage
+                    }
+                ]
+            };
+        }
+    });
+};

package/build/tools/get_job.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import axios from 'axios';
+import { config } from '../config.js';
+import { formatJobDetails } from '../utils/formatters.js';
+export default (server) => {
+    server.tool('get_job', 'Retrieves an agent job by its ID.', {
+        job_id: z.string({
+            description: "The unique identifier of the job you want to retrieve. Example: 'job-12345'."
+        }),
+        org_id: z
+            .string({
+            description: "The organization ID. Example: 'aiconnect'."
+        })
+            .optional()
+    }, async (params) => {
+        const { job_id } = params;
+        const apiUrl = config.AICONNECT_API_URL;
+        const apiKey = config.AICONNECT_API_KEY;
+        if (!apiUrl) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: API URL is not configured. Please set AICONNECT_API_URL environment variable.'
+                    }
+                ]
+            };
+        }
+        if (!apiKey) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: API Key is not configured. Please set AICONNECT_API_KEY environment variable.'
+                    }
+                ]
+            };
+        }
+        const endpoint = `${apiUrl}/services/agent-jobs/${job_id}${params.org_id ? `?org_id=${params.org_id}` : ''}`;
+        const headers = {
+            Authorization: `Bearer ${apiKey}`
+        };
+        try {
+            const response = await axios.get(endpoint, {
+                headers
+            });
+            const job = response.data?.data || response.data;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: formatJobDetails(job)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            let errorMessage = `Failed to retrieve job ${job_id}.`;
+            let errorDetails = {};
+            if (axios.isAxiosError(error) && error.response) {
+                const apiError = error.response.data?.message ||
+                    error.response.data?.error ||
+                    JSON.stringify(error.response.data);
+                errorMessage = `API Error (${error.response.status}): ${apiError || error.message}`;
+                errorDetails = {
+                    status: error.response.status,
+                    data: error.response.data
+                };
+            }
+            else if (error instanceof Error) {
+                errorMessage = `Error: ${error.message}`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: errorMessage
+                    }
+                ]
+            };
+        }
+    });
+};

package/build/tools/get_job_type.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import axios from 'axios';
+import { config } from '../config.js';
+import { formatJobTypeDetails } from '../utils/formatters.js';
+export default (server) => {
+    server.tool('get_job_type', 'Retrieves an agent job type by its ID.', {
+        job_type_id: z.string({
+            description: "The unique identifier of the job type you want to retrieve. Example: 'mood-monitor'."
+        }),
+        org_id: z.string({
+            description: "The organization ID. Example: 'aiconnect'."
+        }).optional()
+    }, async (params) => {
+        const { job_type_id } = params;
+        const org_id = params.org_id || config.DEFAULT_ORG_ID;
+        const apiUrl = config.AICONNECT_API_URL;
+        const apiKey = config.AICONNECT_API_KEY;
+        if (!apiUrl) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: API URL is not configured. Please set AICONNECT_API_URL environment variable.'
+                    }
+                ]
+            };
+        }
+        if (!apiKey) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: API Key is not configured. Please set AICONNECT_API_KEY environment variable.'
+                    }
+                ]
+            };
+        }
+        const endpoint = `${apiUrl}/organizations/${org_id}/agent-jobs-type/${job_type_id}`;
+        const headers = {
+            Authorization: `Bearer ${apiKey}`
+        };
+        try {
+            const response = await axios.get(endpoint, {
+                headers
+            });
+            const jobType = response.data?.data || response.data;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: formatJobTypeDetails(jobType)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            let errorMessage = `Failed to retrieve job type ${job_type_id}.`;
+            let errorDetails = {};
+            if (axios.isAxiosError(error) && error.response) {
+                const apiError = error.response.data?.message ||
+                    error.response.data?.error ||
+                    JSON.stringify(error.response.data);
+                errorMessage = `API Error (${error.response.status}): ${apiError || error.message}`;
+                errorDetails = {
+                    status: error.response.status,
+                    data: error.response.data
+                };
+            }
+            else if (error instanceof Error) {
+                errorMessage = `Error: ${error.message}`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: errorMessage
+                    }
+                ]
+            };
+        }
+    });
+};

package/build/{list_jobs.js → tools/list_jobs.js}

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import axios from 'axios';
-import { config } from './config.js';
+import { config } from '../config.js';
+import { formatJobList } from "../utils/formatters.js";
 // Define the schema for job status based on docs/agent-jobs-api.md:246-251
 const jobStatusSchema = z.enum([
     "waiting",
@@ -12,18 +13,18 @@ const jobStatusSchema = z.enum([
 ]);
 export default (server) => {
     server.tool("list_jobs", "Retrieves a list of agent jobs, with optional filters and pagination.", {
-        org_id: z.string().optional().describe("Filter by organization ID. If not provided, uses the default organization."),
-        status: jobStatusSchema.optional().describe("Filter by job status."),
-        scheduled_at: z.string().datetime().optional().describe("Filter by exact scheduled time (ISO 8601)."),
-        scheduled_at_gte: z.string().datetime().optional().describe("Filter by scheduled time greater than or equal to (ISO 8601)."),
-        scheduled_at_lte: z.string().datetime().optional().describe("Filter by scheduled time less than or equal to (ISO 8601)."),
-        created_at_gte: z.string().datetime().optional().describe("Filter by creation time greater than or equal to (ISO 8601)."),
-        created_at_lte: z.string().datetime().optional().describe("Filter by creation time less than or equal to (ISO 8601)."),
-        job_type_id: z.string().optional().describe("Filter by job type ID."),
-        channel_code: z.string().optional().describe("Filter by channel code."),
-        limit: z.number().int().positive().optional().describe("Maximum number of jobs to return."),
-        offset: z.number().int().nonnegative().optional().describe("Number of jobs to skip (for pagination)."),
-        sort: z.string().optional().describe("Sorting field and direction (e.g., created_at:desc)."),
+        org_id: z.string().optional().describe("Filter by organization ID. If not provided, the default from the environment is used."),
+        status: jobStatusSchema.optional().describe("Filter by job status. Possible values are: 'waiting', 'scheduled', 'running', 'completed', 'failed', 'canceled'."),
+        scheduled_at: z.string().datetime().optional().describe("Filter by the exact scheduled time in ISO 8601 format (e.g., '2024-07-23T10:00:00Z')."),
+        scheduled_at_gte: z.string().datetime().optional().describe("Filter for jobs scheduled at or after a specific time (ISO 8601)."),
+        scheduled_at_lte: z.string().datetime().optional().describe("Filter for jobs scheduled at or before a specific time (ISO 8601)."),
+        created_at_gte: z.string().datetime().optional().describe("Filter for jobs created at or after a specific time (ISO 8601)."),
+        created_at_lte: z.string().datetime().optional().describe("Filter for jobs created at or before a specific time (ISO 8601)."),
+        job_type_id: z.string().optional().describe("Filter by the specific job type ID (e.g., 'daily-report')."),
+        channel_code: z.string().optional().describe("Filter by the channel code (e.g., 'C123456' for a Slack channel)."),
+        limit: z.number().int().positive().optional().describe("Maximum number of jobs to return (e.g.,20). Default is 20."),
+        offset: z.number().int().nonnegative().optional().describe("Number of jobs to skip, used for pagination. Default is 0."),
+        sort: z.string().optional().describe("Field to sort by and direction. Format is 'field:direction'. Example: 'created_at:desc'."),
     }, async (params) => {
         const apiUrl = config.AICONNECT_API_URL;
         const apiKey = config.AICONNECT_API_KEY;
@@ -57,22 +58,27 @@ export default (server) => {
         try {
             const response = await axios.get(endpoint, {
                 headers,
-                params: queryParams, // Axios uses 'params' for query parameters in GET requests
+                params: queryParams,
             });
-            // Return the data part of the response, stringified as JSON text
-            // API docs show jobs under 'data' key, and meta for pagination
+            const jobs = response.data?.data || [];
+            const meta = response.data?.meta || {};
             return {
                 content: [{
                         type: "text",
-                        text: JSON.stringify(response.data, null, 2),
+                        text: formatJobList(jobs, meta),
                     }]
             };
         }
         catch (error) {
             let errorMessage = `Failed to list jobs.`;
+            let errorDetails = {};
             if (axios.isAxiosError(error) && error.response) {
                 const apiError = error.response.data?.message || error.response.data?.error || JSON.stringify(error.response.data);
                 errorMessage = `API Error (${error.response.status}): ${apiError || error.message}`;
+                errorDetails = {
+                    status: error.response.status,
+                    data: error.response.data
+                };
             }
             else if (error instanceof Error) {
                 errorMessage = `Error: ${error.message}`;
@@ -81,7 +87,7 @@ export default (server) => {
                 content: [{
                         type: "text",
                         text: errorMessage,
-                    }]
+                    }],
             };
         }
     });

package/build/utils/formatters.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+// Schema para um job individual, baseado no exemplo fornecido.
+const jobSchema = z.object({
+    job_id: z.string(),
+    channel_code: z.string(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+    scheduled_at: z.string().datetime(),
+    job_status: z.string(),
+    result: z.string().nullable(),
+    job_type_id: z.string(),
+}).passthrough(); // .passthrough() permite outros campos não definidos no schema.
+/**
+ * Formata a resposta completa de um job, ideal para o get_job.
+ * @param job - O objeto do job.
+ * @returns Uma string formatada com os detalhes completos do job.
+ */
+export function formatJobDetails(job) {
+    const fullJobDetails = JSON.stringify(job, null, 2);
+    return `Job Details:\n\n${fullJobDetails}`;
+}
+/**
+ * Formata um resumo de um job, com os campos principais.
+ * @param job - O objeto do job.
+ * @returns Uma string formatada com o resumo do job.
+ */
+export function formatJobSummary(job) {
+    try {
+        const parsedJob = jobSchema.parse(job);
+        return `
+- Job ID: ${parsedJob.job_id}
+- Status: ${parsedJob.job_status}
+- Type: ${parsedJob.job_type_id}
+- Channel: ${parsedJob.channel_code}
+- Scheduled At: ${parsedJob.scheduled_at}
+- Updated At: ${parsedJob.updated_at}
+- Result: ${parsedJob.result || 'N/A'}
+    `.trim();
+    }
+    catch (error) {
+        // Se a validação falhar, retorna o objeto como string.
+        return JSON.stringify(job, null, 2);
+    }
+}
+/**
+ * Formata a resposta para a lista de jobs.
+ * @param jobs - Um array de jobs.
+ * @param pagination - O objeto de paginação.
+ * @returns Uma string formatada com a lista de resumos de jobs.
+ */
+export function formatJobList(jobs, pagination) {
+    if (!jobs || jobs.length === 0) {
+        return "No jobs found for the given criteria.";
+    }
+    const jobSummaries = jobs.map(job => formatJobSummary(job)).join('\n\n');
+    const paginationSummary = `Page: ${Math.floor((pagination.offset || 0) / (pagination.limit || 20)) + 1} | Total Jobs: ${pagination.total}`;
+    return `Found ${jobs.length} jobs.\n\n${jobSummaries}\n\n${paginationSummary}`;
+}
+// Schema for job type details
+const jobTypeSchema = z.object({
+    id: z.string(),
+    org_id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    default_config: z.object({
+        profile_id: z.string(),
+        max_follow_ups: z.number(),
+        max_task_retries: z.number(),
+        task_retry_interval: z.number().describe("The interval in minutes to wait before retrying a task."),
+        max_time_to_complete: z.number().describe("The maximum time in minutes to complete a task."),
+        start_prompt: z.string(),
+    }),
+}).passthrough();
+/**
+ * Formats the response for job type details.
+ * @param jobType - The job type object.
+ * @returns A formatted string with the job type details.
+ */
+export function formatJobTypeDetails(jobType) {
+    try {
+        const parsedJobType = jobTypeSchema.parse(jobType);
+        return `
+- ID: ${parsedJobType.id}
+- Name: ${parsedJobType.name}
+- Description: ${parsedJobType.description}
+- Organization ID: ${parsedJobType.org_id}
+
+Default Configuration:
+- Profile ID: ${parsedJobType.default_config.profile_id}
+- Max Follow-ups: ${parsedJobType.default_config.max_follow_ups}
+- Max Task Retries: ${parsedJobType.default_config.max_task_retries}
+- Task Retry Interval: ${parsedJobType.default_config.task_retry_interval} minutes
+- Max Time to Complete: ${parsedJobType.default_config.max_time_to_complete} minutes
+- Start Prompt: ${parsedJobType.default_config.start_prompt}
+    `.trim();
+    }
+    catch (error) {
+        // If validation fails, return the object as a string.
+        return `Invalid job type details format: ${JSON.stringify(jobType, null, 2)}`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiconnect/agentjobs-mcp",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "MCP (Model Context Protocol) server for managing Agent Jobs in the AI Connect platform. Developed by AI Connect - Advanced AI automation and integration solutions.",
   "type": "module",
   "main": "build/index.js",

package/build/create_job.js

@@ -1,151 +0,0 @@
-import { z } from 'zod';
-import axios from 'axios';
-import { config } from './config.js';
-// Schema for the target_channel object
-const targetChannelSchema = z
-    .object({
-    org_id: z.string().optional().describe('Organization ID for the target channel. If not provided, uses the default organization.'),
-    platform: z
-        .enum(['whatsapp', 'slack', 'web'])
-        .describe('Platform of the target channel.'),
-    type: z.string().describe('Type of the target channel (e.g., channel).'),
-    code: z.string().describe('Code/identifier for the target channel.'),
-    data: z
-        .record(z.any())
-        .optional()
-        .describe('Additional platform-specific data for the channel.')
-})
-    .describe('Defines the target channel for the job.');
-// Schema for the config object
-const configSchema = z
-    .object({
-    max_follow_ups: z
-        .number()
-        .int()
-        .optional()
-        .describe('Maximum number of follow-ups allowed.'),
-    max_task_retries: z
-        .number()
-        .int()
-        .optional()
-        .describe('Maximum number of retries for a task.'),
-    task_retry_interval: z
-        .number()
-        .int()
-        .optional()
-        .describe('Interval in minutes between task retries.'),
-    start_prompt: z.string().describe('The initial prompt to start the job.'),
-    max_time_to_complete: z
-        .number()
-        .int()
-        .optional()
-        .describe('Maximum time in minutes for the job to complete.'),
-    profile_id: z.string().describe('Profile ID to be used for the job.')
-})
-    .describe('Configuration settings for the job.');
-export default (server) => {
-    server.tool('create_job', 'Creates a new agent job.', {
-        target_channel: targetChannelSchema,
-        job_type_id: z.string().describe('The ID of the job type.'),
-        config: configSchema.optional(),
-        params: z
-            .record(z.any())
-            .optional()
-            .describe('Arbitrary parameters for the job.'),
-        scheduled_at: z
-            .string()
-            .datetime({ message: 'Invalid datetime string. Must be ISO 8601' })
-            .optional()
-            .describe('Optional ISO 8601 date string for scheduling the job.'),
-        delay: z
-            .number()
-            .int()
-            .nonnegative()
-            .optional()
-            .describe('Optional maximum random delay in minutes to add to the scheduled time (query parameter).')
-    }, async (toolParams) => {
-        const apiUrl = config.AICONNECT_API_URL;
-        const apiKey = config.AICONNECT_API_KEY;
-        const defaultOrgId = config.DEFAULT_ORG_ID;
-        if (!apiUrl) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Error: API URL is not configured. Please set AICONNECT_API_URL environment variable.'
-                    }
-                ]
-            };
-        }
-        if (!apiKey) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Error: API Key is not configured. Please set AICONNECT_API_KEY environment variable.'
-                    }
-                ]
-            };
-        }
-        // Use default org_id if not provided
-        if (!toolParams.target_channel.org_id && defaultOrgId) {
-            toolParams.target_channel.org_id = defaultOrgId;
-        }
-        else if (!toolParams.target_channel.org_id && !defaultOrgId) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Error: Organization ID is required. Please provide org_id or set DEFAULT_ORG_ID environment variable.'
-                    }
-                ]
-            };
-        }
-        const endpoint = `${apiUrl}/services/agent-jobs`;
-        const headers = {
-            Authorization: `Bearer ${apiKey}`,
-            'Content-Type': 'application/json'
-        };
-        // Separate delay as it's a query parameter
-        const { delay, ...bodyPayload } = toolParams;
-        const queryParams = {};
-        if (delay !== undefined) {
-            queryParams.delay = delay;
-        }
-        try {
-            const response = await axios.post(endpoint, bodyPayload, {
-                headers,
-                params: queryParams
-            });
-            // API returns job details under 'data' key
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2)
-                    }
-                ]
-            };
-        }
-        catch (error) {
-            let errorMessage = `Failed to create job.`;
-            if (axios.isAxiosError(error) && error.response) {
-                const apiError = error.response.data?.message ||
-                    error.response.data?.error ||
-                    JSON.stringify(error.response.data);
-                errorMessage = `API Error (${error.response.status}): ${apiError || error.message}`;
-            }
-            else if (error instanceof Error) {
-                errorMessage = `Error: ${error.message}`;
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: errorMessage
-                    }
-                ]
-            };
-        }
-    });
-};

package/build/get_job.js

@@ -1,62 +0,0 @@
-import { z } from "zod";
-import axios from 'axios';
-import { config } from './config.js';
-export default (server) => {
-    server.tool("get_job", "Retrieves an agent job by its ID.", {
-        job_id: z.string({
-            description: "The ID of the job to retrieve.",
-        }),
-    }, async (params) => {
-        const { job_id } = params;
-        const apiUrl = config.AICONNECT_API_URL;
-        const apiKey = config.AICONNECT_API_KEY;
-        if (!apiUrl) {
-            return {
-                content: [{
-                        type: "text",
-                        text: "Error: API URL is not configured. Please set AICONNECT_API_URL environment variable."
-                    }]
-            };
-        }
-        if (!apiKey) {
-            return {
-                content: [{
-                        type: "text",
-                        text: "Error: API Key is not configured. Please set AICONNECT_API_KEY environment variable."
-                    }]
-            };
-        }
-        const endpoint = `${apiUrl}/services/agent-jobs/${job_id}`;
-        const headers = {
-            "Authorization": `Bearer ${apiKey}`,
-        };
-        try {
-            const response = await axios.get(endpoint, {
-                headers,
-            });
-            // Return the data part of the response, stringified as JSON text
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(response.data?.data || response.data, null, 2),
-                    }]
-            };
-        }
-        catch (error) {
-            let errorMessage = `Failed to retrieve job ${job_id}.`;
-            if (axios.isAxiosError(error) && error.response) {
-                const apiError = error.response.data?.message || error.response.data?.error || JSON.stringify(error.response.data);
-                errorMessage = `API Error (${error.response.status}): ${apiError || error.message}`;
-            }
-            else if (error instanceof Error) {
-                errorMessage = `Error: ${error.message}`;
-            }
-            return {
-                content: [{
-                        type: "text",
-                        text: errorMessage,
-                    }]
-            };
-        }
-    });
-};