@holon-run/agentinbox 1.0.3 → 1.0.5

package/dist/src/current_agent.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.summarizeActivationTarget = summarizeActivationTarget;
+exports.isHolonRuntimeEnv = isHolonRuntimeEnv;
+exports.detectHolonRuntimeContext = detectHolonRuntimeContext;
 exports.resolveCurrentAgent = resolveCurrentAgent;
 exports.annotateAgents = annotateAgents;
+exports.isHolonRuntimeContext = isHolonRuntimeContext;
 function summarizeActivationTarget(target) {
     if (target.kind === "terminal") {
         return {
@@ -25,6 +28,19 @@ function summarizeActivationTarget(target) {
         status: target.status,
     };
 }
+function isHolonRuntimeEnv(env = process.env) {
+    return normalizeOptionalString(env.HOLON_RUNTIME) === "1";
+}
+function detectHolonRuntimeContext(env = process.env) {
+    if (!isHolonRuntimeEnv(env)) {
+        return null;
+    }
+    const agentId = normalizeOptionalString(env.HOLON_AGENT_ID);
+    if (!agentId) {
+        return null;
+    }
+    return { runtimeKind: "holon", agentId, externalTriggerUrl: normalizeOptionalString(env.HOLON_EXTERNAL_TRIGGER_URL) };
+}
 function resolveCurrentAgent(agents, context) {
     if (!context) {
         return null;
@@ -62,6 +78,9 @@ function annotateAgents(agents, context) {
     };
 }
 function resolveAgentRecord(agents, context) {
+    if (isHolonRuntimeContext(context)) {
+        return agents.find((agent) => agent.agent.status === "active" && agent.agent.agentId === context.agentId) ?? null;
+    }
     if (context.tmuxPaneId) {
         const match = agents.find((agent) => terminalTargetsForCurrentMatch(agent).some((target) => target.backend === "tmux" && target.tmuxPaneId === context.tmuxPaneId));
         if (match) {
@@ -129,6 +148,9 @@ function terminalIdentityForAgent(agent) {
     return null;
 }
 function matchesCurrentTerminal(agent, context) {
+    if (isHolonRuntimeContext(context)) {
+        return false;
+    }
     return terminalTargetsForCurrentMatch(agent).some((target) => (context.tmuxPaneId != null && target.tmuxPaneId === context.tmuxPaneId)
         || (context.itermSessionId != null && target.itermSessionId === context.itermSessionId)
         || (context.tty != null && target.tty === context.tty));
@@ -137,9 +159,18 @@ function matchesCurrentRuntime(agent, context) {
     if (agent.agent.status !== "active") {
         return false;
     }
+    if (isHolonRuntimeContext(context)) {
+        return agent.agent.agentId === context.agentId;
+    }
     if (!context.runtimeSessionId) {
         return false;
     }
     return activeTerminalTargets(agent).some((target) => target.runtimeKind === context.runtimeKind && target.runtimeSessionId === context.runtimeSessionId) || (agent.agent.runtimeKind === context.runtimeKind
         && agent.agent.runtimeSessionId === context.runtimeSessionId);
 }
+function isHolonRuntimeContext(context) {
+    return context.runtimeKind === "holon" && "agentId" in context;
+}
+function normalizeOptionalString(value) {
+    return value?.trim() || null;
+}

package/dist/src/http.js

@@ -133,6 +133,13 @@ function buildFastifyServer(service) {
     app.get("/hosts", {
         schema: {
             tags: ["sources"],
+            querystring: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    limit: { type: "string", pattern: "^[1-9][0-9]*$" },
+                },
+            },
             response: {
                 200: {
                     type: "object",
@@ -143,7 +150,10 @@ function buildFastifyServer(service) {
                 },
             },
         },
-    }, async () => ({ hosts: service.listHosts() }));
+    }, async (request) => {
+        const query = request.query;
+        return { hosts: service.listHosts(parseOptionalPositiveInteger(query.limit)) };
+    });
     app.post("/hosts", {
         schema: {
             tags: ["sources"],
@@ -206,6 +216,13 @@ function buildFastifyServer(service) {
     app.get("/streams", {
         schema: {
             tags: ["sources"],
+            querystring: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    limit: { type: "string", pattern: "^[1-9][0-9]*$" },
+                },
+            },
             response: {
                 200: {
                     type: "object",
@@ -216,7 +233,10 @@ function buildFastifyServer(service) {
                 },
             },
         },
-    }, async () => ({ streams: service.listStreams() }));
+    }, async (request) => {
+        const query = request.query;
+        return { streams: service.listStreams(parseOptionalPositiveInteger(query.limit)) };
+    });
     app.post("/streams", {
         schema: {
             tags: ["sources"],
@@ -280,6 +300,13 @@ function buildFastifyServer(service) {
     app.get("/sources", {
         schema: {
             tags: ["sources"],
+            querystring: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    limit: { type: "string", pattern: "^[1-9][0-9]*$" },
+                },
+            },
             response: {
                 200: {
                     type: "object",
@@ -290,7 +317,10 @@ function buildFastifyServer(service) {
                 },
             },
         },
-    }, async () => ({ sources: await service.listSourceViews() }));
+    }, async (request) => {
+        const query = request.query;
+        return { sources: await service.listSourceViews(parseOptionalPositiveInteger(query.limit)) };
+    });
     app.post("/sources", {
         schema: {
             tags: ["sources"],
@@ -351,6 +381,60 @@ function buildFastifyServer(service) {
         const params = request.params;
         return service.getResolvedSourceSchema(decodeURIComponent(params.sourceId));
     });
+    app.get("/sources/:sourceId/actions", {
+        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.listSourceOperations(decodeURIComponent(params.sourceId));
+    });
+    app.post("/sources/:sourceId/invoke", {
+        schema: {
+            tags: ["sources"],
+            params: {
+                type: "object",
+                required: ["sourceId"],
+                properties: {
+                    sourceId: { type: "string", minLength: 1 },
+                },
+            },
+            body: {
+                type: "object",
+                additionalProperties: false,
+                required: ["operation", "input"],
+                properties: {
+                    operation: { type: "string", minLength: 1 },
+                    input: jsonObjectSchema,
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                400: errorResponseSchema,
+                404: errorResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const params = request.params;
+        const body = request.body;
+        return service.invokeSourceOperation({
+            sourceId: decodeURIComponent(params.sourceId),
+            operation: body.operation,
+            input: body.input,
+        });
+    });
     app.patch("/streams/:streamId", {
         schema: {
             tags: ["sources"],
@@ -548,6 +632,7 @@ function buildFastifyServer(service) {
                     occurredAt: { type: "string", minLength: 1 },
                     metadata: jsonObjectSchema,
                     rawPayload: jsonObjectSchema,
+                    providerRawPayload: jsonObjectSchema,
                 },
             },
             response: {
@@ -564,6 +649,7 @@ function buildFastifyServer(service) {
             occurredAt: body.occurredAt,
             metadata: body.metadata ?? {},
             rawPayload: body.rawPayload ?? {},
+            providerRawPayload: body.providerRawPayload,
         });
     });
     app.delete("/sources/:sourceId", {
@@ -702,6 +788,7 @@ function buildFastifyServer(service) {
                     occurredAt: { type: "string", minLength: 1 },
                     metadata: jsonObjectSchema,
                     rawPayload: jsonObjectSchema,
+                    providerRawPayload: jsonObjectSchema,
                     deliveryHandle: deliveryHandleSchema,
                 },
             },
@@ -719,6 +806,7 @@ function buildFastifyServer(service) {
             occurredAt: optionalString(body.occurredAt),
             metadata: body.metadata ?? {},
             rawPayload: body.rawPayload ?? {},
+            providerRawPayload: body.providerRawPayload,
             deliveryHandle: body.deliveryHandle ?? null,
         });
     });
@@ -730,6 +818,7 @@ function buildFastifyServer(service) {
                 additionalProperties: false,
                 properties: {
                     include_targets: { type: "string", enum: ["true", "false"] },
+                    limit: { type: "string", pattern: "^[1-9][0-9]*$" },
                 },
             },
             response: {
@@ -744,17 +833,10 @@ function buildFastifyServer(service) {
         },
     }, async (request) => {
         const query = request.query;
-        const agents = service.listAgents();
+        const agents = service.listAgents(parseOptionalPositiveInteger(query.limit));
         if (query.include_targets === "true") {
-            const activationTargetsByAgentId = service.listActivationTargets().reduce((grouped, target) => {
-                const targets = grouped.get(target.agentId);
-                const summarized = (0, current_agent_1.summarizeActivationTarget)(target);
-                if (targets) {
-                    targets.push(summarized);
-                }
-                else {
-                    grouped.set(target.agentId, [summarized]);
-                }
+            const activationTargetsByAgentId = agents.reduce((grouped, agent) => {
+                grouped.set(agent.agentId, service.listActivationTargets(agent.agentId).map((target) => (0, current_agent_1.summarizeActivationTarget)(target)));
                 return grouped;
             }, new Map());
             return {
@@ -920,6 +1002,13 @@ function buildFastifyServer(service) {
                     agentId: { type: "string", minLength: 1 },
                 },
             },
+            querystring: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    limit: { type: "string", pattern: "^[1-9][0-9]*$" },
+                },
+            },
             response: {
                 200: {
                     type: "object",
@@ -932,7 +1021,8 @@ function buildFastifyServer(service) {
         },
     }, async (request) => {
         const params = request.params;
-        return { targets: service.listActivationTargets(decodeURIComponent(params.agentId)) };
+        const query = request.query;
+        return { targets: service.listActivationTargets(decodeURIComponent(params.agentId), parseOptionalPositiveInteger(query.limit)) };
     });
     app.post("/agents/:agentId/targets", {
         schema: {
@@ -1017,6 +1107,7 @@ function buildFastifyServer(service) {
                 additionalProperties: false,
                 properties: {
                     agent_id: { type: "string" },
+                    limit: { type: "string", pattern: "^[1-9][0-9]*$" },
                 },
             },
             response: {
@@ -1031,7 +1122,7 @@ function buildFastifyServer(service) {
         },
     }, async (request) => {
         const query = request.query;
-        return { timers: service.listTimers(query.agent_id) };
+        return { timers: service.listTimers(query.agent_id, parseOptionalPositiveInteger(query.limit)) };
     });
     app.post("/timers", {
         schema: {
@@ -1135,6 +1226,7 @@ function buildFastifyServer(service) {
                 properties: {
                     source_id: { type: "string" },
                     agent_id: { type: "string" },
+                    limit: { type: "string", pattern: "^[1-9][0-9]*$" },
                 },
             },
             response: {
@@ -1147,6 +1239,7 @@ function buildFastifyServer(service) {
             subscriptions: service.listSubscriptions({
                 sourceId: query.source_id,
                 agentId: query.agent_id,
+                limit: parseOptionalPositiveInteger(query.limit),
             }),
         };
     });
@@ -1348,6 +1441,7 @@ function buildFastifyServer(service) {
                 properties: {
                     after_entry_id: { type: "string" },
                     include_acked: { type: "string", enum: ["true", "false"] },
+                    limit: { type: "string", pattern: "^[1-9][0-9]*$" },
                 },
             },
             response: {
@@ -1367,6 +1461,7 @@ function buildFastifyServer(service) {
             entries: service.listInboxItems(decodeURIComponent(params.agentId), {
                 afterEntryId: query.after_entry_id,
                 includeAcked: query.include_acked ? query.include_acked === "true" : undefined,
+                limit: parseOptionalPositiveInteger(query.limit),
             }),
         };
     });
@@ -1738,6 +1833,19 @@ function optionalString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
+function parseOptionalPositiveInteger(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!/^[1-9]\d*$/.test(value)) {
+        throw new Error("expected positive integer");
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(parsed)) {
+        throw new Error("expected positive integer within safe range");
+    }
+    return parsed;
+}
 function normalizeValidationMessage(message) {
     if (message.includes("must be boolean")) {
         return "expected boolean";
@@ -1762,10 +1870,13 @@ function isBadRequestError(message) {
         message.startsWith("deliver send is not supported") ||
         message.startsWith("deliveryHandle requires") ||
         message.startsWith("delivery operations are not supported") ||
+        message.startsWith("source operations are not supported") ||
         message.startsWith("unknown GitHub delivery operation") ||
         message.startsWith("unknown Feishu delivery operation") ||
+        message.startsWith("unknown Feishu source operation") ||
         message.startsWith("invalid GitHub targetRef") ||
-        message.includes("requires input.text") ||
+        message.startsWith("get_message_context requires") ||
+        message.includes("requires input.") ||
         message.includes("requires input.body") ||
         message.startsWith("subscriptions/reset requires") ||
         message.startsWith("agents requires") ||

package/dist/src/service.js

@@ -144,14 +144,14 @@ class AgentInboxService {
         await this.adapters.sourceAdapterFor(source.sourceType).ensureSource(source);
         return source;
     }
-    listSources() {
-        return this.store.listSources();
+    listSources(limit) {
+        return this.store.listSources(limit);
     }
-    async listSourceViews() {
-        return this.attachSourceRuntimes(this.store.listSources());
+    async listSourceViews(limit) {
+        return this.attachSourceRuntimes(this.store.listSources(limit));
     }
-    listHosts() {
-        return this.store.listSourceHosts();
+    listHosts(limit) {
+        return this.store.listSourceHosts(limit);
     }
     getHost(hostId) {
         const host = this.store.getSourceHost(hostId);
@@ -269,8 +269,8 @@ class AgentInboxService {
             return this.getStream(stream.sourceId);
         });
     }
-    listStreams() {
-        return this.listSources();
+    listStreams(limit) {
+        return this.listSources(limit);
     }
     getStream(streamId) {
         return this.getSource(streamId);
@@ -282,6 +282,22 @@ class AgentInboxService {
         const source = this.getSource(sourceId);
         return this.adapters.resolveSourceSchema(source);
     }
+    async listSourceOperations(sourceId) {
+        const source = this.getSource(sourceId);
+        return {
+            sourceId: source.sourceId,
+            operations: await this.adapters.listSourceOperations(source),
+        };
+    }
+    async invokeSourceOperation(request) {
+        const source = this.getSource(request.sourceId);
+        const data = await this.adapters.invokeSourceOperation(source, request.operation, request.input);
+        return {
+            sourceId: source.sourceId,
+            operation: request.operation,
+            data,
+        };
+    }
     async previewSourceSchema(input) {
         try {
             const source = buildPreviewSource(input);
@@ -590,8 +606,8 @@ class AgentInboxService {
             notifyLeaseMs: notifyLeaseMs ?? null,
         });
     }
-    listAgents() {
-        return this.store.listAgents();
+    listAgents(limit) {
+        return this.store.listAgents(limit);
     }
     getAgent(agentId) {
         const agent = this.store.getAgent(agentId);
@@ -666,12 +682,12 @@ class AgentInboxService {
         this.rescheduleTimerSync();
         return timer;
     }
-    listTimers(agentId) {
+    listTimers(agentId, limit) {
         if (agentId) {
             this.getAgent(agentId);
-            return this.store.listTimersForAgent(agentId);
+            return this.store.listTimersForAgent(agentId, limit);
         }
-        return this.store.listTimers();
+        return this.store.listTimers(limit);
     }
     getTimer(scheduleId) {
         const timer = this.store.getTimer(scheduleId);
@@ -758,12 +774,12 @@ class AgentInboxService {
         this.markAgentActive(agentId);
         return target;
     }
-    listActivationTargets(agentId) {
+    listActivationTargets(agentId, limit) {
         if (agentId) {
             this.getAgent(agentId);
-            return this.store.listActivationTargetsForAgent(agentId);
+            return this.store.listActivationTargetsForAgent(agentId, limit);
         }
-        return this.store.listActivationTargets();
+        return this.store.listActivationTargets(limit);
     }
     getActivationTarget(targetId) {
         const target = this.store.getActivationTarget(targetId);
@@ -1024,15 +1040,7 @@ class AgentInboxService {
         return { removed: true, subscriptionId };
     }
     listSubscriptions(filters) {
-        return this.store.listSubscriptions().filter((subscription) => {
-            if (filters?.sourceId && subscription.sourceId !== filters.sourceId) {
-                return false;
-            }
-            if (filters?.agentId && subscription.agentId !== filters.agentId) {
-                return false;
-            }
-            return true;
-        });
+        return this.store.listSubscriptionsFiltered(filters);
     }
     getSubscription(subscriptionId) {
         const subscription = this.store.getSubscription(subscriptionId);
@@ -1098,8 +1106,8 @@ class AgentInboxService {
         }
         return this.appendSourceEvent({ ...input, sourceId });
     }
-    listInboxAgentIds() {
-        return this.store.listInboxes().map((inbox) => inbox.ownerAgentId);
+    listInboxAgentIds(limit) {
+        return this.store.listInboxes(limit).map((inbox) => inbox.ownerAgentId);
     }
     getInboxDetailsByAgent(agentId) {
         const inbox = this.ensureInboxForAgent(agentId);
@@ -1193,6 +1201,7 @@ class AgentInboxService {
             occurredAt,
             metadata: {},
             rawPayload: input.rawPayload,
+            providerRawPayload: undefined,
             deliveryHandle: null,
             ackedAt: null,
         };
@@ -1516,6 +1525,7 @@ class AgentInboxService {
                             subscriptionId: subscription.subscriptionId,
                         },
                         rawPayload: event.rawPayload,
+                        providerRawPayload: event.providerRawPayload,
                         deliveryHandle: event.deliveryHandle,
                         ackedAt: null,
                     };
@@ -3406,6 +3416,7 @@ function activationItemFromInboxItem(item) {
         occurredAt: item.occurredAt,
         metadata: item.metadata,
         rawPayload: item.rawPayload,
+        providerRawPayload: item.providerRawPayload,
         deliveryHandle: item.deliveryHandle,
     };
 }
@@ -3882,9 +3893,7 @@ function getHostConfigFields(hostType) {
             ];
         case "feishu":
             return [
-                { name: "appId", type: "string", description: "Feishu app ID.", required: true },
-                { name: "appSecret", type: "string", description: "Feishu app secret.", required: true },
-                { name: "uxcAuth", type: "string", description: "Optional shared Feishu auth/runtime profile.", required: false },
+                { name: "uxcAuth", type: "string", description: "Optional shared Feishu/Lark UXC auth profile.", required: false },
             ];
         case "local_event":
             return [];

package/dist/src/source_hosts.js

@@ -32,13 +32,11 @@ function resolveSourceRegistration(input) {
     if (input.sourceType === "feishu_bot") {
         return {
             hostType: "feishu",
-            hostKey: `app:${stringOrDefault(config.appId, input.configRef ?? input.sourceKey)}`,
+            hostKey: `uxcAuth:${stringOrDefault(config.uxcAuth, input.configRef ?? input.sourceKey)}`,
             hostConfig: {
-                ...(valueOrUndefined(config.appId) ? { appId: config.appId } : {}),
-                ...(valueOrUndefined(config.appSecret) ? { appSecret: config.appSecret } : {}),
+                ...(valueOrUndefined(config.uxcAuth) ? { uxcAuth: config.uxcAuth } : {}),
                 ...(valueOrUndefined(config.schemaUrl) ? { schemaUrl: config.schemaUrl } : {}),
                 ...(valueOrUndefined(config.replyInThread) ? { replyInThread: config.replyInThread } : {}),
-                ...(valueOrUndefined(config.uxcAuth) ? { uxcAuth: config.uxcAuth } : {}),
             },
             streamKind: "message_events",
             streamKey: input.sourceKey,

package/dist/src/source_schema.js

@@ -146,13 +146,11 @@ const SOURCE_SCHEMAS = {
         ],
         eventVariantExamples: ["im.message.receive_v1.text"],
         configFields: [
-            { name: "appId", type: "string", required: true, description: "Feishu app ID." },
-            { name: "appSecret", type: "string", required: true, description: "Feishu app secret." },
+            { name: "uxcAuth", type: "string", required: false, description: "Optional UXC auth profile for the Feishu/Lark app." },
             { name: "eventTypes", type: "string[]", required: false, description: "Optional Feishu event type allowlist." },
             { name: "chatIds", type: "string[]", required: false, description: "Optional Feishu chat allowlist." },
             { name: "schemaUrl", type: "string", required: false, description: "Optional Feishu OpenAPI schema URL." },
             { name: "replyInThread", type: "boolean", required: false, description: "Reply in thread when sending outbound messages." },
-            { name: "uxcAuth", type: "string", required: false, description: "Optional uxc auth profile." },
         ],
     },
 };