@love-moon/conductor-sdk 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @love-moon/conductor-sdk
 
+## 0.7.0
+
+### Minor Changes
+
+- 689fc50: Add scheduled message management APIs and conductor task schedule list/create/delete commands.
+
+## 0.6.1
+
 ## 0.6.0
 
 ## 0.5.1

package/dist/api/index.d.ts

@@ -1,4 +1,4 @@
 export { ProjectsApi, type Project, type CreateProjectInput, type ListProjectsOptions, type ResolveProjectInput, } from './projects.js';
 export { IssuesApi, type Issue, type ListIssuesInput, type CreateIssueInput, type UpdateIssueInput, type UpdateIssueStatusOptions, } from './issues.js';
-export { TasksApi, type Task, type Message, type ListTasksInput, type SendTaskMessageOptions, type ListTaskMessagesOptions, } from './tasks.js';
+export { TasksApi, type Task, type Message, type ListTasksInput, type SendTaskMessageOptions, type ListTaskMessagesOptions, type ScheduledMessage, type ScheduledMessageSchedule, type CreateScheduledMessageInput, } from './tasks.js';
 export { ProjectNotResolvedError, buildAuditMetadata, isBackendApiError, type ApiClient, type SdkClientOptions, } from './shared.js';

package/dist/api/shared.d.ts

@@ -1,5 +1,5 @@
 import { BackendApiClient, BackendApiError } from '../backend/index.js';
-export type ApiClient = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'getProject' | 'updateProject' | 'patchProjectByQuery' | 'setDefaultProject' | 'matchProjectByPath' | 'listIssues' | 'getIssue' | 'createIssue' | 'patchIssue' | 'deleteIssue' | 'listTasks' | 'getTask' | 'listTaskMessages' | 'postTaskMessage'>;
+export type ApiClient = Pick<BackendApiClient, 'listProjects' | 'createProject' | 'getProject' | 'updateProject' | 'patchProjectByQuery' | 'setDefaultProject' | 'matchProjectByPath' | 'listIssues' | 'getIssue' | 'createIssue' | 'patchIssue' | 'deleteIssue' | 'listTasks' | 'getTask' | 'listTaskMessages' | 'postTaskMessage' | 'postTaskInsert' | 'listScheduledMessages' | 'createScheduledMessage' | 'deleteScheduledMessage'>;
 export interface SdkClientOptions {
     /**
      * Optional override for the SDK version stamped onto audit metadata. Falls

package/dist/api/tasks.d.ts

@@ -21,6 +21,51 @@ export interface Message {
     createdAt?: string | null;
     raw: Record<string, unknown>;
 }
+export type ScheduledMessageSchedule = {
+    mode: 'delay';
+    amount: number;
+    unit: 'minute' | 'hour';
+} | {
+    mode: 'at';
+    sendAt: string;
+    timezone?: string | null;
+} | {
+    mode: 'interval';
+    every: number;
+    unit: 'minute' | 'hour';
+    condition?: 'none' | 'ai_idle';
+    stop?: {
+        maxRuns?: number | null;
+        maxSkips?: number | null;
+        stopAt?: string | null;
+        stopWhenTaskNotRunning?: boolean | null;
+    } | null;
+};
+export interface ScheduledMessage {
+    id: string;
+    userId?: string | null;
+    taskId: string;
+    sourceMessageId?: string | null;
+    content: string;
+    kind: string;
+    condition: string;
+    intervalMs?: number | null;
+    timezone?: string | null;
+    status: string;
+    nextRunAt: string;
+    runCount: number;
+    skipCount: number;
+    failureCount: number;
+    maxRuns?: number | null;
+    maxSkips?: number | null;
+    stopAt?: string | null;
+    stopWhenTaskNotRunning: boolean;
+    lastRunAt?: string | null;
+    lastError?: string | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    raw: Record<string, unknown>;
+}
 export interface ListTasksInput {
     projectId?: string;
     issueId?: string;
@@ -31,10 +76,23 @@ export interface SendTaskMessageOptions {
     metadata?: Record<string, unknown>;
     clientRequestId?: string;
 }
+export interface InsertTaskMessageOptions {
+    metadata?: Record<string, unknown>;
+    /**
+     * The reply target of the in-flight turn to interrupt. When omitted, the
+     * server resolves the most recent user message as the target.
+     */
+    targetReplyTo?: string;
+}
 export interface ListTaskMessagesOptions {
     limit?: number;
     before?: string;
 }
+export interface CreateScheduledMessageInput {
+    content: string;
+    schedule: ScheduledMessageSchedule;
+    sourceMessageId?: string | null;
+}
 export declare class TasksApi {
     private readonly client;
     private readonly options;
@@ -42,5 +100,15 @@ export declare class TasksApi {
     listTasks(input?: ListTasksInput): Promise<Task[]>;
     getTask(taskId: string): Promise<Task>;
     sendTaskMessage(taskId: string, content: string, options?: SendTaskMessageOptions): Promise<Message>;
+    /**
+     * Insert a mid-turn message into a running task. The message is delivered and
+     * the in-flight turn is interrupted so the inserted message runs next, instead
+     * of being queued until the current turn finishes (which is what
+     * {@link sendTaskMessage} does).
+     */
+    insertTaskMessage(taskId: string, content: string, options?: InsertTaskMessageOptions): Promise<Message>;
     listTaskMessages(taskId: string, options?: ListTaskMessagesOptions): Promise<Message[]>;
+    listScheduledMessages(taskId: string): Promise<ScheduledMessage[]>;
+    createScheduledMessage(taskId: string, input: CreateScheduledMessageInput): Promise<ScheduledMessage>;
+    deleteScheduledMessage(taskId: string, scheduleId: string): Promise<void>;
 }

package/dist/api/tasks.js

@@ -43,6 +43,53 @@ const normalizeMessage = (payload) => {
         raw: payload,
     };
 };
+const normalizeNumber = (value, fallback = 0) => {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return fallback;
+};
+const normalizeScheduledMessage = (payload) => {
+    const id = payload.id ? String(payload.id) : '';
+    if (!id) {
+        throw new Error('Scheduled message payload missing id');
+    }
+    const taskId = payload.taskId ?? payload.task_id;
+    if (!taskId) {
+        throw new Error('Scheduled message payload missing taskId');
+    }
+    return {
+        id,
+        userId: payload.userId ?? payload.user_id ?? null,
+        taskId: String(taskId),
+        sourceMessageId: payload.sourceMessageId ?? payload.source_message_id ?? null,
+        content: typeof payload.content === 'string' ? payload.content : '',
+        kind: String(payload.kind ?? ''),
+        condition: String(payload.condition ?? 'none'),
+        intervalMs: payload.intervalMs ?? payload.interval_ms ?? null,
+        timezone: payload.timezone ?? null,
+        status: String(payload.status ?? ''),
+        nextRunAt: String(payload.nextRunAt ?? payload.next_run_at ?? ''),
+        runCount: normalizeNumber(payload.runCount ?? payload.run_count),
+        skipCount: normalizeNumber(payload.skipCount ?? payload.skip_count),
+        failureCount: normalizeNumber(payload.failureCount ?? payload.failure_count),
+        maxRuns: payload.maxRuns ?? payload.max_runs ?? null,
+        maxSkips: payload.maxSkips ?? payload.max_skips ?? null,
+        stopAt: payload.stopAt ?? payload.stop_at ?? null,
+        stopWhenTaskNotRunning: Boolean(payload.stopWhenTaskNotRunning ?? payload.stop_when_task_not_running),
+        lastRunAt: payload.lastRunAt ?? payload.last_run_at ?? null,
+        lastError: payload.lastError ?? payload.last_error ?? null,
+        createdAt: payload.createdAt ?? payload.created_at ?? null,
+        updatedAt: payload.updatedAt ?? payload.updated_at ?? null,
+        raw: payload,
+    };
+};
 export class TasksApi {
     client;
     options;
@@ -104,6 +151,31 @@ export class TasksApi {
         const payload = await this.client.postTaskMessage(trimmed, body);
         return normalizeMessage(payload);
     }
+    /**
+     * Insert a mid-turn message into a running task. The message is delivered and
+     * the in-flight turn is interrupted so the inserted message runs next, instead
+     * of being queued until the current turn finishes (which is what
+     * {@link sendTaskMessage} does).
+     */
+    async insertTaskMessage(taskId, content, options = {}) {
+        const trimmed = String(taskId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('taskId is required');
+        }
+        if (typeof content !== 'string' || content.length === 0) {
+            throw new Error('content is required');
+        }
+        const metadata = buildAuditMetadata(options.metadata, this.options);
+        const body = {
+            content,
+            metadata,
+        };
+        if (options.targetReplyTo) {
+            body.target_reply_to = options.targetReplyTo;
+        }
+        const payload = await this.client.postTaskInsert(trimmed, body);
+        return normalizeMessage(payload.message ?? payload);
+    }
     async listTaskMessages(taskId, options = {}) {
         const trimmed = String(taskId ?? '').trim();
         if (!trimmed) {
@@ -115,4 +187,45 @@ export class TasksApi {
         });
         return messages.map((entry) => normalizeMessage(entry));
     }
+    async listScheduledMessages(taskId) {
+        const trimmed = String(taskId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('taskId is required');
+        }
+        const schedules = await this.client.listScheduledMessages(trimmed);
+        return schedules.map((entry) => normalizeScheduledMessage(entry));
+    }
+    async createScheduledMessage(taskId, input) {
+        const trimmed = String(taskId ?? '').trim();
+        if (!trimmed) {
+            throw new Error('taskId is required');
+        }
+        const content = typeof input?.content === 'string' ? input.content.trim() : '';
+        if (!content) {
+            throw new Error('content is required');
+        }
+        if (!input?.schedule || typeof input.schedule !== 'object') {
+            throw new Error('schedule is required');
+        }
+        const body = {
+            content,
+            schedule: input.schedule,
+        };
+        if (Object.prototype.hasOwnProperty.call(input, 'sourceMessageId')) {
+            body.sourceMessageId = input.sourceMessageId ?? null;
+        }
+        const schedule = await this.client.createScheduledMessage(trimmed, body);
+        return normalizeScheduledMessage(schedule);
+    }
+    async deleteScheduledMessage(taskId, scheduleId) {
+        const trimmedTaskId = String(taskId ?? '').trim();
+        const trimmedScheduleId = String(scheduleId ?? '').trim();
+        if (!trimmedTaskId) {
+            throw new Error('taskId is required');
+        }
+        if (!trimmedScheduleId) {
+            throw new Error('scheduleId is required');
+        }
+        await this.client.deleteScheduledMessage(trimmedTaskId, trimmedScheduleId);
+    }
 }

package/dist/backend/client.d.ts

@@ -216,6 +216,15 @@ export declare class BackendApiClient {
      * endpoint directly here. (RFC 0025 §2 picks the simpler path.)
      */
     postTaskMessage(taskId: string, params: Record<string, unknown>): Promise<Record<string, any>>;
+    /**
+     * POST /tasks/[taskId]/insert — insert a mid-turn message. Unlike
+     * {@link postTaskMessage}, which queues a message for after the current turn,
+     * this interrupts the running turn so the inserted message is processed next.
+     */
+    postTaskInsert(taskId: string, params: Record<string, unknown>): Promise<Record<string, any>>;
+    listScheduledMessages(taskId: string): Promise<Record<string, any>[]>;
+    createScheduledMessage(taskId: string, params: Record<string, unknown>): Promise<Record<string, any>>;
+    deleteScheduledMessage(taskId: string, scheduleId: string): Promise<void>;
     private request;
     private buildUrl;
     private sendRequest;

package/dist/backend/client.js

@@ -410,6 +410,37 @@ export class BackendApiClient {
         });
         return this.parseJson(response);
     }
+    /**
+     * POST /tasks/[taskId]/insert — insert a mid-turn message. Unlike
+     * {@link postTaskMessage}, which queues a message for after the current turn,
+     * this interrupts the running turn so the inserted message is processed next.
+     */
+    async postTaskInsert(taskId, params) {
+        const response = await this.request('POST', `/tasks/${taskId}/insert`, {
+            body: JSON.stringify(params),
+        });
+        return this.parseJson(response);
+    }
+    async listScheduledMessages(taskId) {
+        const response = await this.request('GET', `/tasks/${taskId}/scheduled-messages`);
+        const payload = await this.parseJson(response);
+        if (payload && typeof payload === 'object' && Array.isArray(payload.schedules)) {
+            return payload.schedules;
+        }
+        if (Array.isArray(payload)) {
+            return payload;
+        }
+        throw new BackendApiError('Invalid scheduled messages response', response.status, payload);
+    }
+    async createScheduledMessage(taskId, params) {
+        const response = await this.request('POST', `/tasks/${taskId}/scheduled-messages`, {
+            body: JSON.stringify(params),
+        });
+        return this.parseJson(response);
+    }
+    async deleteScheduledMessage(taskId, scheduleId) {
+        await this.request('DELETE', `/tasks/${taskId}/scheduled-messages/${scheduleId}`);
+    }
     async request(method, pathname, opts = {}) {
         const url = this.buildUrl(pathname, opts.query);
         const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -33,5 +33,5 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"
   },
-  "gitCommitId": "2f914a7"
+  "gitCommitId": "ed4e3ab"
 }