@stamn/stamn-plugin 0.1.0-alpha.27 → 0.1.0-alpha.29

package/dist/index.js

@@ -5085,6 +5085,7 @@ function readOpenclawConfig() {
   return readJsonFile(getConfigPath()) ?? {};
 }
 var STAMN_TOOL_NAMES = [
+  "stamn_ping",
   "stamn_world_status",
   "stamn_get_events",
   "stamn_get_balance",
@@ -5331,16 +5332,19 @@ function respondToService(ws) {
       properties: {
         requestId: param("string", "The requestId from the incoming event."),
         output: param("string", "The result/output of the service."),
-        success: param("string", "Whether it succeeded.", { enum: ["true", "false"] })
+        success: param("string", "Whether it succeeded.", { enum: ["true", "false"] }),
+        domain: param("string", 'Optional domain tag for experience tracking (e.g. "typescript-nestjs-monorepos").')
       },
       required: ["requestId", "output", "success"]
     },
     execute: (_id, args) => {
-      ws.send("participant:service_result", {
+      const payload = {
         requestId: args.requestId,
         output: args.output,
         success: args.success === "true"
-      });
+      };
+      if (args.domain) payload.domain = args.domain;
+      ws.send("participant:service_result", payload);
       return text(`Service response sent for request ${args.requestId}.`);
     }
   };
@@ -5550,6 +5554,272 @@ function spend(ws) {
     }
   };
 }
+function ping() {
+  return {
+    name: "stamn_ping",
+    description: "Diagnostic ping. Returns OK if the Stamn plugin tools are loaded and reachable by the agent.",
+    parameters: NO_PARAMS,
+    execute: () => text("pong \u2014 stamn plugin tools are loaded and reachable.")
+  };
+}
+function getReputation(ws) {
+  return {
+    name: "stamn_get_reputation",
+    description: "Get your reputation score and reviews. Returns trust score (0-1000), completion rate, review average, and score breakdown.",
+    parameters: NO_PARAMS,
+    execute: () => {
+      ws.send("participant:get_reviews", {});
+      return text("Reputation request sent. Check events for the response (server:reviews).");
+    }
+  };
+}
+function reviewService(ws) {
+  return {
+    name: "stamn_review_service",
+    description: "Rate a completed service you purchased. Only the buyer can review. Rating is 1-5 stars.",
+    parameters: {
+      type: "object",
+      properties: {
+        requestId: param("string", "The requestId of the completed service job."),
+        rating: param("string", "Rating from 1 to 5.", { enum: ["1", "2", "3", "4", "5"] }),
+        comment: param("string", "Optional review comment.")
+      },
+      required: ["requestId", "rating"]
+    },
+    execute: (_id, args) => {
+      ws.send("participant:service_review", {
+        requestId: args.requestId,
+        rating: Number(args.rating),
+        ...args.comment ? { comment: args.comment } : {}
+      });
+      return text(`Review submitted for request ${args.requestId}. Check events for confirmation.`);
+    }
+  };
+}
+function getReviews(ws) {
+  return {
+    name: "stamn_get_reviews",
+    description: "Get reviews received for your services along with your reputation score.",
+    parameters: NO_PARAMS,
+    execute: () => {
+      ws.send("participant:get_reviews", {});
+      return text("Reviews request sent. Check events for the response (server:reviews).");
+    }
+  };
+}
+function getExperience(ws) {
+  return {
+    name: "stamn_get_experience",
+    description: "Get your experience profiles \u2014 verifiable work history by service tag and domain. Shows jobs completed, success rate, volume, and response time.",
+    parameters: NO_PARAMS,
+    execute: () => {
+      ws.send("participant:get_experience", {});
+      return text("Experience request sent. Check events for the response (server:experience).");
+    }
+  };
+}
+function searchExperts(ws) {
+  return {
+    name: "stamn_search_experts",
+    description: "Search for agents with proven experience in a domain or service tag. Find the best provider for a task based on verifiable track record.",
+    parameters: {
+      type: "object",
+      properties: {
+        domain: param("string", 'Domain to search for (e.g. "typescript", "data-analysis"). Partial match supported.'),
+        serviceTag: param("string", "Exact service tag to filter by."),
+        minJobs: param("number", "Minimum number of completed jobs."),
+        minSuccessRate: param("number", "Minimum success rate (0-1, e.g. 0.95 for 95%)."),
+        limit: param("number", "Max results to return (default 20).")
+      }
+    },
+    execute: (_id, args) => {
+      const payload = {};
+      if (args.domain) payload.domain = args.domain;
+      if (args.serviceTag) payload.serviceTag = args.serviceTag;
+      if (args.minJobs) payload.minJobs = Number(args.minJobs);
+      if (args.minSuccessRate) payload.minSuccessRate = Number(args.minSuccessRate);
+      if (args.limit) payload.limit = Number(args.limit);
+      ws.send("participant:search_experts", payload);
+      return text("Expert search sent. Check events for the response (server:experts).");
+    }
+  };
+}
+function declareCapability(ws) {
+  return {
+    name: "stamn_declare_capability",
+    description: "Declare a capability (tool, integration, hardware, access, or credential) that you have. This is stored in your profile and helps buyers find you.",
+    parameters: {
+      type: "object",
+      properties: {
+        capabilityType: param("string", "Type of capability.", { enum: ["tool", "integration", "hardware", "access", "credential"] }),
+        name: param("string", 'Short name for the capability (e.g. "web-search", "github-api").'),
+        description: param("string", "What this capability lets you do."),
+        provider: param("string", 'Optional provider/platform (e.g. "Google", "GitHub").')
+      },
+      required: ["capabilityType", "name", "description"]
+    },
+    execute: (_id, args) => {
+      const payload = {
+        capabilityType: args.capabilityType,
+        name: args.name,
+        description: args.description
+      };
+      if (args.provider) payload.provider = args.provider;
+      ws.send("participant:capability_declare", payload);
+      return text(`Capability "${args.name}" declaration sent. Check events for confirmation (server:capability_declared).`);
+    }
+  };
+}
+function removeCapability(ws) {
+  return {
+    name: "stamn_remove_capability",
+    description: "Remove a previously declared capability from your profile.",
+    parameters: {
+      type: "object",
+      properties: {
+        capabilityType: param("string", "Type of capability.", { enum: ["tool", "integration", "hardware", "access", "credential"] }),
+        name: param("string", "Name of the capability to remove.")
+      },
+      required: ["capabilityType", "name"]
+    },
+    execute: (_id, args) => {
+      ws.send("participant:capability_remove", {
+        capabilityType: args.capabilityType,
+        name: args.name
+      });
+      return text(`Capability removal sent. Check events for confirmation (server:capability_removed).`);
+    }
+  };
+}
+function listCapabilities(ws) {
+  return {
+    name: "stamn_list_capabilities",
+    description: "List all capabilities you have declared.",
+    parameters: NO_PARAMS,
+    execute: () => {
+      ws.send("participant:capability_list", {});
+      return text("Capability list requested. Check events for the response (server:capability_list).");
+    }
+  };
+}
+function searchCapabilities(ws) {
+  return {
+    name: "stamn_search_capabilities",
+    description: "Search for agents with specific capabilities. Find agents that have the tools or integrations you need.",
+    parameters: {
+      type: "object",
+      properties: {
+        capabilityType: param("string", "Filter by type.", { enum: ["tool", "integration", "hardware", "access", "credential"] }),
+        name: param("string", "Search by capability name (partial match)."),
+        provider: param("string", "Filter by provider (partial match)."),
+        limit: param("number", "Max results (default 20).")
+      }
+    },
+    execute: (_id, args) => {
+      const payload = {};
+      if (args.capabilityType) payload.capabilityType = args.capabilityType;
+      if (args.name) payload.name = args.name;
+      if (args.provider) payload.provider = args.provider;
+      if (args.limit) payload.limit = Number(args.limit);
+      ws.send("participant:search_capabilities", payload);
+      return text("Capability search sent. Check events for the response (server:search_results).");
+    }
+  };
+}
+function setHybridMode(ws) {
+  return {
+    name: "stamn_set_hybrid_mode",
+    description: "Set your hybrid mode: autonomous (fully AI), human_backed (AI with human escalation), or human_operated (human drives, AI assists).",
+    parameters: {
+      type: "object",
+      properties: {
+        mode: param("string", "The hybrid mode.", { enum: ["autonomous", "human_backed", "human_operated"] }),
+        humanRole: param("string", 'Role of the human (e.g. "Senior Engineer", "Domain Expert").'),
+        escalationTriggers: param("string", 'Comma-separated triggers for escalation (e.g. "complex-bug,security-review").'),
+        humanAvailabilityHours: param("string", 'Availability window (e.g. "9am-5pm PST").')
+      },
+      required: ["mode"]
+    },
+    execute: (_id, args) => {
+      const payload = {
+        mode: args.mode
+      };
+      if (args.humanRole) payload.humanRole = args.humanRole;
+      if (args.escalationTriggers) {
+        payload.escalationTriggers = args.escalationTriggers.split(",").map((s) => s.trim());
+      }
+      if (args.humanAvailabilityHours) payload.humanAvailabilityHours = args.humanAvailabilityHours;
+      ws.send("participant:set_hybrid_mode", payload);
+      return text(`Hybrid mode update sent. Check events for confirmation (server:hybrid_mode_updated).`);
+    }
+  };
+}
+function addCredential(ws) {
+  return {
+    name: "stamn_add_credential",
+    description: "Add a verified credential to your profile (e.g. certification, license, degree). Credentials are initially unverified.",
+    parameters: {
+      type: "object",
+      properties: {
+        credentialType: param("string", 'Type (e.g. "certification", "license", "degree", "membership").'),
+        title: param("string", 'Title of the credential (e.g. "AWS Solutions Architect").'),
+        issuer: param("string", 'Issuing organization (e.g. "Amazon Web Services").')
+      },
+      required: ["credentialType", "title", "issuer"]
+    },
+    execute: (_id, args) => {
+      ws.send("participant:add_credential", {
+        credentialType: args.credentialType,
+        title: args.title,
+        issuer: args.issuer
+      });
+      return text(`Credential submission sent. Check events for confirmation (server:credential_added).`);
+    }
+  };
+}
+function requestEscalation(ws) {
+  return {
+    name: "stamn_escalation_request",
+    description: "Request human escalation for a task you cannot handle alone. Only relevant for human_backed or human_operated agents.",
+    parameters: {
+      type: "object",
+      properties: {
+        trigger: param("string", 'What triggered the escalation (e.g. "complex-bug", "security-review", "domain-expertise").'),
+        context: param("string", "Context for the human \u2014 what you need help with."),
+        serviceJobId: param("string", "Optional service job ID this escalation relates to.")
+      },
+      required: ["trigger", "context"]
+    },
+    execute: (_id, args) => {
+      const payload = {
+        trigger: args.trigger,
+        context: args.context
+      };
+      if (args.serviceJobId) payload.serviceJobId = args.serviceJobId;
+      ws.send("participant:escalation_request", payload);
+      return text(`Escalation request sent. Check events for confirmation (server:escalation_created).`);
+    }
+  };
+}
+function resolveEscalation(ws) {
+  return {
+    name: "stamn_escalation_resolve",
+    description: "Mark an escalation as resolved after human intervention is complete.",
+    parameters: {
+      type: "object",
+      properties: {
+        escalationId: param("string", "The escalation ID to resolve.")
+      },
+      required: ["escalationId"]
+    },
+    execute: (_id, args) => {
+      ws.send("participant:escalation_resolved", {
+        escalationId: args.escalationId
+      });
+      return text(`Escalation resolution sent. Check events for confirmation (server:escalation_resolved).`);
+    }
+  };
+}
 function allTools(ws, agentId) {
   return [
     worldStatus(ws),
@@ -5564,7 +5834,20 @@ function allTools(ws, agentId) {
     updateServiceListing(ws),
     listServiceListings(ws),
     chatReply(ws, agentId),
-    spend(ws)
+    spend(ws),
+    getReputation(ws),
+    reviewService(ws),
+    getReviews(ws),
+    getExperience(ws),
+    searchExperts(ws),
+    declareCapability(ws),
+    removeCapability(ws),
+    listCapabilities(ws),
+    searchCapabilities(ws),
+    setHybridMode(ws),
+    addCredential(ws),
+    requestEscalation(ws),
+    resolveEscalation(ws)
   ];
 }
 function withAuthGuard(tool, ws) {
@@ -5580,6 +5863,7 @@ function withAuthGuard(tool, ws) {
   };
 }
 function registerTools(api, wsService, config) {
+  api.registerTool(ping());
   for (const tool of allTools(wsService, config.agentId)) {
     api.registerTool(withAuthGuard(tool, wsService));
   }
@@ -5733,7 +6017,8 @@ var ServerEvent = {
   HEARTBEAT_ACK: "server:heartbeat_ack",
   WORLD_UPDATE: "server:world_update",
   BALANCE: "server:balance",
-  OWNER_CHAT_MESSAGE: "server:owner_chat_message"
+  OWNER_CHAT_MESSAGE: "server:owner_chat_message",
+  SERVICE_INCOMING: "server:service_incoming"
 };
 var ClientEvent = {
   AUTHENTICATE: "participant:authenticate",
@@ -5759,6 +6044,7 @@ var StamnWsService = class {
   createSocket;
   ownerChatHandler;
   messageHandlers;
+  serviceRequestHandler;
   constructor(opts) {
     this.config = opts.config;
     this.logger = opts.logger;
@@ -5772,7 +6058,8 @@ var StamnWsService = class {
       [ServerEvent.HEARTBEAT_ACK]: () => this.logger.debug("Heartbeat acknowledged"),
       [ServerEvent.WORLD_UPDATE]: (d) => this.onWorldUpdate(d),
       [ServerEvent.BALANCE]: (d) => this.onBalanceUpdate(d),
-      [ServerEvent.OWNER_CHAT_MESSAGE]: (d) => this.handleOwnerChat(d)
+      [ServerEvent.OWNER_CHAT_MESSAGE]: (d) => this.handleOwnerChat(d),
+      [ServerEvent.SERVICE_INCOMING]: (d) => this.handleServiceIncoming(d)
     };
   }
   async start() {
@@ -5815,6 +6102,9 @@ var StamnWsService = class {
   setOwnerChatHandler(handler) {
     this.ownerChatHandler = handler;
   }
+  setServiceRequestHandler(handler) {
+    this.serviceRequestHandler = handler;
+  }
   connect() {
     this.logger.info(`Connecting to ${this.wsUrl}...`);
     try {
@@ -6013,6 +6303,11 @@ var StamnWsService = class {
     this.bufferEvent(ServerEvent.OWNER_CHAT_MESSAGE, payload);
     this.ownerChatHandler?.(payload);
   }
+  handleServiceIncoming(payload) {
+    this.logger.info(`Service request: ${payload.serviceTag} from ${payload.fromParticipantName} (${payload.requestId})`);
+    this.bufferEvent(ServerEvent.SERVICE_INCOMING, payload);
+    this.serviceRequestHandler?.(payload);
+  }
   bufferEvent(event, data) {
     if (this.eventBuffer.length >= MAX_EVENT_BUFFER_SIZE) {
       this.eventBuffer.shift();
@@ -6168,6 +6463,9 @@ var index_default = {
     wsService.setOwnerChatHandler((payload) => {
       dispatchOwnerChat(api, wsService, payload, agentId);
     });
+    wsService.setServiceRequestHandler((payload) => {
+      dispatchServiceRequest(api, wsService, payload, agentId);
+    });
     api.registerService({
       id: "stamn-ws",
       start: () => wsService.start(),
@@ -6235,6 +6533,59 @@ function dispatchOwnerChat(api, wsService, payload, agentId) {
     api.logger.error(`[stamn-channel] dispatchOwnerChat threw: ${err}`);
   }
 }
+function dispatchServiceRequest(api, _wsService, payload, agentId) {
+  api.logger.info(
+    `[stamn-channel] service request: ${payload.serviceTag} from ${payload.fromParticipantName}`
+  );
+  if (!api.runtime?.channel?.reply) {
+    api.logger.warn("[stamn-channel] channel.reply not available \u2014 cannot dispatch service request");
+    return;
+  }
+  const reply = api.runtime.channel.reply;
+  try {
+    const { dispatcher, replyOptions } = reply.createReplyDispatcherWithTyping({
+      deliver: async () => {
+      },
+      channel: "stamn",
+      accountId: agentId
+    });
+    const bodyForAgent = [
+      `SERVICE REQUEST \u2014 You have an incoming paid service request. Process it immediately.`,
+      ``,
+      `Service: ${payload.serviceTag}`,
+      `From: ${payload.fromParticipantName}`,
+      `Price: ${payload.offeredPriceCents} cents USDC`,
+      `Request ID: ${payload.requestId}`,
+      ``,
+      `Input:`,
+      payload.input,
+      ``,
+      `Respond using stamn_service_respond with requestId "${payload.requestId}".`
+    ].join("\n");
+    reply.dispatchReplyFromConfig({
+      ctx: {
+        BodyForAgent: bodyForAgent,
+        ChatType: "direct",
+        MessageSid: payload.requestId,
+        SessionKey: `agent:main:stamn:service:${agentId}`,
+        Provider: "stamn",
+        Surface: "stamn",
+        From: payload.fromParticipantName
+      },
+      cfg: api.config,
+      dispatcher,
+      replyOptions
+    }).then(() => {
+      api.logger.info(
+        `[stamn-channel] service request dispatched for ${payload.serviceTag} (${payload.requestId})`
+      );
+    }).catch((err) => {
+      api.logger.error(`[stamn-channel] service request dispatch failed: ${err}`);
+    });
+  } catch (err) {
+    api.logger.error(`[stamn-channel] dispatchServiceRequest threw: ${err}`);
+  }
+}
 export {
   StamnWsService,
   createOpenclawAdapter,