@holon-run/agentinbox 0.1.4 → 0.3.0

package/dist/src/http.js

@@ -149,6 +149,26 @@ function buildFastifyServer(service) {
         const params = request.params;
         return service.getSourceDetails(decodeURIComponent(params.sourceId));
     });
+    app.get("/sources/:sourceId/schema", {
+        schema: {
+            tags: ["sources"],
+            params: {
+                type: "object",
+                required: ["sourceId"],
+                properties: {
+                    sourceId: { type: "string", minLength: 1 },
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                400: errorResponseSchema,
+                404: errorResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const params = request.params;
+        return service.getResolvedSourceSchema(decodeURIComponent(params.sourceId));
+    });
     app.delete("/sources/:sourceId", {
         schema: {
             tags: ["sources"],
@@ -159,6 +179,18 @@ function buildFastifyServer(service) {
                     sourceId: { type: "string", minLength: 1 },
                 },
             },
+            querystring: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    with_subscriptions: {
+                        anyOf: [
+                            { type: "boolean" },
+                            { type: "string", enum: ["true", "false", "1", "0"] },
+                        ],
+                    },
+                },
+            },
             response: {
                 200: jsonObjectSchema,
                 400: errorResponseSchema,
@@ -166,7 +198,10 @@ function buildFastifyServer(service) {
         },
     }, async (request) => {
         const params = request.params;
-        return service.removeSource(decodeURIComponent(params.sourceId));
+        const query = request.query;
+        return service.removeSource(decodeURIComponent(params.sourceId), {
+            withSubscriptions: query.with_subscriptions === true || query.with_subscriptions === "true" || query.with_subscriptions === "1",
+        });
     });
     app.patch("/sources/:sourceId", {
         schema: {
@@ -250,6 +285,25 @@ function buildFastifyServer(service) {
         const params = request.params;
         return service.getSourceSchema(decodeURIComponent(params.sourceType));
     });
+    app.post("/sources/schema-preview", {
+        schema: {
+            tags: ["sources"],
+            body: {
+                type: "object",
+                additionalProperties: false,
+                required: ["sourceRef"],
+                properties: {
+                    sourceRef: { type: "string", minLength: 1 },
+                    configRef: { anyOf: [{ type: "string" }, { type: "null" }] },
+                    config: jsonObjectSchema,
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                400: errorResponseSchema,
+            },
+        },
+    }, async (request) => service.previewSourceSchema(request.body));
     app.post("/sources/:sourceId/poll", {
         schema: {
             tags: ["sources"],
@@ -365,6 +419,7 @@ function buildFastifyServer(service) {
                     backend: { type: "string", minLength: 1 },
                     runtimeKind: { type: "string" },
                     runtimeSessionId: { type: "string" },
+                    runtimePid: { type: "integer", minimum: 1 },
                     tmuxPaneId: { type: "string" },
                     tty: { type: "string" },
                     termProgram: { type: "string" },
@@ -385,6 +440,7 @@ function buildFastifyServer(service) {
             backend: String(body.backend),
             runtimeKind: optionalString(body.runtimeKind),
             runtimeSessionId: optionalString(body.runtimeSessionId),
+            runtimePid: typeof body.runtimePid === "number" ? body.runtimePid : null,
             mode: "agent_prompt",
             tmuxPaneId: optionalString(body.tmuxPaneId),
             tty: optionalString(body.tty),
@@ -509,6 +565,123 @@ function buildFastifyServer(service) {
         const params = request.params;
         return service.removeActivationTarget(decodeURIComponent(params.agentId), decodeURIComponent(params.targetId));
     });
+    app.get("/timers", {
+        schema: {
+            tags: ["timers"],
+            querystring: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    agent_id: { type: "string" },
+                },
+            },
+            response: {
+                200: {
+                    type: "object",
+                    required: ["timers"],
+                    properties: {
+                        timers: { type: "array", items: jsonObjectSchema },
+                    },
+                },
+            },
+        },
+    }, async (request) => {
+        const query = request.query;
+        return { timers: service.listTimers(query.agent_id) };
+    });
+    app.post("/timers", {
+        schema: {
+            tags: ["timers"],
+            body: {
+                type: "object",
+                additionalProperties: false,
+                required: ["agentId", "message"],
+                properties: {
+                    agentId: { type: "string", minLength: 1 },
+                    at: { type: "string", minLength: 1 },
+                    every: { type: "integer", minimum: 60000 },
+                    cron: { type: "string", minLength: 1 },
+                    timezone: { type: "string", minLength: 1 },
+                    message: { type: "string", minLength: 1 },
+                    sender: { type: "string", minLength: 1 },
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                400: errorResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const body = request.body;
+        return service.registerTimer({
+            agentId: String(body.agentId),
+            at: optionalString(body.at) ?? null,
+            every: typeof body.every === "number" ? body.every : null,
+            cron: optionalString(body.cron) ?? null,
+            timezone: optionalString(body.timezone) ?? null,
+            message: String(body.message),
+            sender: optionalString(body.sender) ?? null,
+        });
+    });
+    app.post("/timers/:scheduleId/pause", {
+        schema: {
+            tags: ["timers"],
+            params: {
+                type: "object",
+                required: ["scheduleId"],
+                properties: {
+                    scheduleId: { type: "string", minLength: 1 },
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                400: errorResponseSchema,
+                404: errorResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const params = request.params;
+        return service.pauseTimer(decodeURIComponent(params.scheduleId));
+    });
+    app.post("/timers/:scheduleId/resume", {
+        schema: {
+            tags: ["timers"],
+            params: {
+                type: "object",
+                required: ["scheduleId"],
+                properties: {
+                    scheduleId: { type: "string", minLength: 1 },
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                400: errorResponseSchema,
+                404: errorResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const params = request.params;
+        return service.resumeTimer(decodeURIComponent(params.scheduleId));
+    });
+    app.delete("/timers/:scheduleId", {
+        schema: {
+            tags: ["timers"],
+            params: {
+                type: "object",
+                required: ["scheduleId"],
+                properties: {
+                    scheduleId: { type: "string", minLength: 1 },
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                404: errorResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const params = request.params;
+        return service.removeTimer(decodeURIComponent(params.scheduleId));
+    });
     app.get("/subscriptions", {
         schema: {
             tags: ["subscriptions"],
@@ -549,9 +722,18 @@ function buildFastifyServer(service) {
                 properties: {
                     agentId: { type: "string", minLength: 1 },
                     sourceId: { type: "string", minLength: 1 },
+                    shortcut: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["name"],
+                        properties: {
+                            name: { type: "string", minLength: 1 },
+                            args: jsonObjectSchema,
+                        },
+                    },
                     filter: jsonObjectSchema,
-                    lifecycleMode: { type: "string" },
-                    expiresAt: { type: "string" },
+                    trackedResourceRef: { type: "string" },
+                    cleanupPolicy: jsonObjectSchema,
                     startPolicy: { type: "string" },
                     startOffset: { type: "integer" },
                     startTime: { type: "string" },
@@ -567,9 +749,17 @@ function buildFastifyServer(service) {
         return service.registerSubscription({
             agentId: String(body.agentId),
             sourceId: String(body.sourceId),
-            filter: body.filter ?? {},
-            lifecycleMode: optionalString(body.lifecycleMode),
-            expiresAt: optionalString(body.expiresAt) ?? null,
+            shortcut: body.shortcut && typeof body.shortcut === "object"
+                ? {
+                    name: String(body.shortcut.name),
+                    args: body.shortcut.args ?? undefined,
+                }
+                : undefined,
+            filter: body.filter && typeof body.filter === "object"
+                ? body.filter
+                : undefined,
+            trackedResourceRef: optionalString(body.trackedResourceRef) ?? null,
+            cleanupPolicy: body.cleanupPolicy,
             startPolicy: optionalString(body.startPolicy),
             startOffset: typeof body.startOffset === "number" ? body.startOffset : undefined,
             startTime: optionalString(body.startTime) ?? undefined,
@@ -741,6 +931,39 @@ function buildFastifyServer(service) {
             }),
         };
     });
+    app.post("/agents/:agentId/inbox/items", {
+        schema: {
+            tags: ["inbox"],
+            params: {
+                type: "object",
+                required: ["agentId"],
+                properties: {
+                    agentId: { type: "string", minLength: 1 },
+                },
+            },
+            body: {
+                type: "object",
+                additionalProperties: false,
+                required: ["message"],
+                properties: {
+                    message: { type: "string", minLength: 1 },
+                    sender: { type: "string", minLength: 1 },
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                400: errorResponseSchema,
+                404: errorResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const params = request.params;
+        const body = request.body;
+        return service.addDirectInboxTextMessage(decodeURIComponent(params.agentId), {
+            message: body.message,
+            sender: body.sender ?? null,
+        });
+    });
     app.get("/agents/:agentId/inbox/watch", {
         schema: {
             tags: ["inbox"],
@@ -989,7 +1212,11 @@ function normalizeValidationMessage(message) {
     return message;
 }
 function isBadRequestError(message) {
-    return (message.startsWith("manual append is not supported") ||
+    return (message.startsWith("direct inbox ") ||
+        message.startsWith("timers require ") ||
+        message.startsWith("timer ") ||
+        message.startsWith("invalid timezone: ") ||
+        message.startsWith("manual append is not supported") ||
         message.startsWith("sources/events requires") ||
         message.startsWith("source remove requires") ||
         message.startsWith("deliveryHandle requires") ||
@@ -999,9 +1226,16 @@ function isBadRequestError(message) {
         message.startsWith("subscriptions requires") ||
         message.startsWith("agent register conflict") ||
         message.startsWith("unsupported activation target kind") ||
-        message.startsWith("unsupported lifecycle mode") ||
+        message.startsWith("unsupported cleanup policy mode") ||
         message.startsWith("unsupported start policy") ||
         message.startsWith("unsupported terminal") ||
+        message.startsWith("cleanupPolicy ") ||
+        message.startsWith("trackedResourceRef ") ||
+        message.startsWith("preview failed: ") ||
+        message.startsWith("unknown source kind or type for preview") ||
+        message.startsWith("preview source kind ") ||
+        message.startsWith("subscription add shortcut") ||
+        message.startsWith("unknown subscription shortcut ") ||
         message.startsWith("expected boolean") ||
         message.startsWith("expected integer") ||
         message.startsWith("expected positive integer") ||