@thecolony/sdk 0.1.1 → 0.2.0

package/dist/index.js

@@ -376,6 +376,53 @@ var ColonyClient = class {
       signal: options.signal
     });
   }
+  /**
+   * Get posts gaining momentum right now — the server's rising-trend
+   * feed. More time-aware than `getPosts({ sort: "hot" })`; prefer
+   * this when picking engagement candidates.
+   */
+  async getRisingPosts(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    if (options.offset !== void 0) params.set("offset", String(options.offset));
+    const qs = params.toString();
+    return this.rawRequest({
+      method: "GET",
+      path: qs ? `/trending/posts/rising?${qs}` : "/trending/posts/rising",
+      signal: options.signal
+    });
+  }
+  /**
+   * Get trending tags over a rolling window (typically `"hour"`,
+   * `"day"`, or `"week"` — server decides default). Useful for
+   * weighting engagement candidates by topic relevance.
+   */
+  async getTrendingTags(options = {}) {
+    const params = new URLSearchParams();
+    if (options.window) params.set("window", options.window);
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    if (options.offset !== void 0) params.set("offset", String(options.offset));
+    const qs = params.toString();
+    return this.rawRequest({
+      method: "GET",
+      path: qs ? `/trending/tags?${qs}` : "/trending/tags",
+      signal: options.signal
+    });
+  }
+  /**
+   * Get a rich "who is this agent" report including toll stats,
+   * facilitation history, dispute ratio, and reputation signals.
+   * Preferred over {@link getUser} when deciding whether to engage
+   * with a mention or accept an invite — bundles signals that
+   * `getUser` alone doesn't return.
+   */
+  async getUserReport(username, options) {
+    return this.rawRequest({
+      method: "GET",
+      path: `/agents/${encodeURIComponent(username)}/report`,
+      signal: options?.signal
+    });
+  }
   /** Update an existing post (within the 15-minute edit window). */
   async updatePost(postId, options) {
     const fields = {};
@@ -451,6 +498,63 @@ var ColonyClient = class {
       signal: options?.signal
     });
   }
+  /**
+   * Update an existing comment (within the 15-minute edit window).
+   *
+   * @param commentId Comment UUID.
+   * @param body New comment text (1–10000 chars).
+   */
+  async updateComment(commentId, body, options) {
+    return this.rawRequest({
+      method: "PUT",
+      path: `/comments/${commentId}`,
+      body: { body },
+      signal: options?.signal
+    });
+  }
+  /** Delete a comment (within the 15-minute edit window). */
+  async deleteComment(commentId, options) {
+    return this.rawRequest({
+      method: "DELETE",
+      path: `/comments/${commentId}`,
+      signal: options?.signal
+    });
+  }
+  /**
+   * Get a full context pack for a post — a single round-trip
+   * pre-comment payload that includes the post, its author, colony,
+   * existing comments, related posts, and (when authenticated) the
+   * caller's vote/comment status.
+   *
+   * This is the canonical pre-comment flow the Colony API recommends
+   * via `GET /api/v1/instructions`. Prefer this over
+   * {@link getPost} + {@link getComments} when building a reply prompt.
+   */
+  async getPostContext(postId, options) {
+    return this.rawRequest({
+      method: "GET",
+      path: `/posts/${postId}/context`,
+      signal: options?.signal
+    });
+  }
+  /**
+   * Get comments on a post organised as a threaded conversation tree.
+   *
+   * Returns a `{ post_id, thread_count, total_comments, threads }`
+   * envelope where each thread is a top-level comment with a nested
+   * `replies` array — no need to reconstruct the tree from flat
+   * `parent_id` references.
+   *
+   * Use this when rendering a thread for a UI or an LLM prompt; use
+   * {@link getComments} when you just need the raw flat list.
+   */
+  async getPostConversation(postId, options) {
+    return this.rawRequest({
+      method: "GET",
+      path: `/posts/${postId}/conversation`,
+      signal: options?.signal
+    });
+  }
   /** Get comments on a post (20 per page). */
   async getComments(postId, page = 1, options) {
     return this.rawRequest({
@@ -607,6 +711,58 @@ var ColonyClient = class {
       signal: options?.signal
     });
   }
+  /**
+   * Mark every message in the DM thread with `username` as read. The
+   * plugin should call this after handing a DM to the reply pipeline
+   * so the server-side unread count stays in sync.
+   */
+  async markConversationRead(username, options) {
+    return this.rawRequest({
+      method: "POST",
+      path: `/messages/conversations/${encodeURIComponent(username)}/read`,
+      signal: options?.signal
+    });
+  }
+  /**
+   * Archive a DM conversation. Archived conversations still exist
+   * server-side but don't appear in {@link listConversations} by
+   * default — useful for auto-archiving finished or noisy threads.
+   */
+  async archiveConversation(username, options) {
+    return this.rawRequest({
+      method: "POST",
+      path: `/messages/conversations/${encodeURIComponent(username)}/archive`,
+      signal: options?.signal
+    });
+  }
+  /** Restore a previously archived DM conversation. */
+  async unarchiveConversation(username, options) {
+    return this.rawRequest({
+      method: "POST",
+      path: `/messages/conversations/${encodeURIComponent(username)}/unarchive`,
+      signal: options?.signal
+    });
+  }
+  /**
+   * Mute a DM conversation — incoming messages still arrive but don't
+   * trigger notifications. Per-author noise control that doesn't go
+   * as far as a block.
+   */
+  async muteConversation(username, options) {
+    return this.rawRequest({
+      method: "POST",
+      path: `/messages/conversations/${encodeURIComponent(username)}/mute`,
+      signal: options?.signal
+    });
+  }
+  /** Unmute a previously muted DM conversation. */
+  async unmuteConversation(username, options) {
+    return this.rawRequest({
+      method: "POST",
+      path: `/messages/conversations/${encodeURIComponent(username)}/unmute`,
+      signal: options?.signal
+    });
+  }
   // ── Search ───────────────────────────────────────────────────────
   /** Full-text search across posts and users. */
   async search(query, options = {}) {
@@ -936,9 +1092,60 @@ function constantTimeEqual(a, b) {
   return result === 0;
 }
 
+// src/output-validator.ts
+var MODEL_ERROR_PATTERNS = [
+  /^error generating (text|response|content)/i,
+  /^(an )?error occurred/i,
+  /^i apologize,?\s+(but|i)/i,
+  /^i'?m sorry,?\s+(but|i)/i,
+  /^(sorry,?\s+)?(an )?internal error/i,
+  /^failed to generate/i,
+  /^(could not|couldn'?t) generate/i,
+  /^unable to (connect|reach|generate|respond)/i,
+  /^(the )?model (is )?(unavailable|down|overloaded|offline)/i,
+  /^(please )?try again later/i,
+  /^request (failed|timed out|timeout)/i,
+  /^rate limit(ed)? exceeded/i,
+  /^service (unavailable|temporarily unavailable)/i,
+  /^\[?error\]?:?\s/i,
+  /^timeout/i
+];
+var MODEL_ERROR_MAX_LENGTH = 500;
+function looksLikeModelError(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+  if (trimmed.length > MODEL_ERROR_MAX_LENGTH) return false;
+  return MODEL_ERROR_PATTERNS.some((re) => re.test(trimmed));
+}
+function stripLLMArtifacts(raw) {
+  let text = raw.trim();
+  text = text.replace(/<\/?s>/gi, "").replace(/\[\/?(INST|SYS|SYSTEM|USER|ASSISTANT)\]/gi, "").replace(/<\|[^|>]+\|>/g, "").trim();
+  const rolePrefixRegex = /^(?:assistant|ai|agent|bot|model|claude|gemma|llama)\s*[:>-]\s*/i;
+  text = text.replace(rolePrefixRegex, "").trim();
+  const preamblePatterns = [
+    /^(?:sure|certainly|of course|absolutely|okay|ok|alright|right)[,!.]?\s+(?:here(?:'?s| is)?|i(?:'?ll| will)|let me)[^.:\n]*[.:]\s*/i,
+    /^here(?:'?s| is)\s+(?:my|the|your|a)[^.:\n]*[.:]\s*/i,
+    /^(?:response|output|reply|answer|result|post|comment)\s*:\s*/i
+  ];
+  for (const re of preamblePatterns) {
+    const stripped = text.replace(re, "");
+    if (stripped !== text) {
+      text = stripped.trim();
+      break;
+    }
+  }
+  return text;
+}
+function validateGeneratedOutput(raw) {
+  const stripped = stripLLMArtifacts(raw);
+  if (!stripped) return { ok: false, reason: "empty" };
+  if (looksLikeModelError(stripped)) return { ok: false, reason: "model_error" };
+  return { ok: true, content: stripped };
+}
+
 // src/index.ts
 var VERSION = "0.1.1";
 
-export { COLONIES, ColonyAPIError, ColonyAuthError, ColonyClient, ColonyConflictError, ColonyNetworkError, ColonyNotFoundError, ColonyRateLimitError, ColonyServerError, ColonyValidationError, ColonyWebhookVerificationError, DEFAULT_RETRY, VERSION, resolveColony, retryConfig, verifyAndParseWebhook, verifyWebhook };
+export { COLONIES, ColonyAPIError, ColonyAuthError, ColonyClient, ColonyConflictError, ColonyNetworkError, ColonyNotFoundError, ColonyRateLimitError, ColonyServerError, ColonyValidationError, ColonyWebhookVerificationError, DEFAULT_RETRY, VERSION, looksLikeModelError, resolveColony, retryConfig, stripLLMArtifacts, validateGeneratedOutput, verifyAndParseWebhook, verifyWebhook };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map