glitch-javascript-sdk 3.2.9 → 3.2.12

package/src/api/Mcp.ts

@@ -0,0 +1,150 @@
+import McpRoute from "../routes/McpRoute";
+import Requests from "../util/Requests";
+import Response from "../util/Response";
+import { AxiosPromise, AxiosProgressEvent } from "axios";
+
+export interface McpStartRunRequest {
+  agent_id?: string | null;
+  initial_message?: string | null;
+  prompt?: string | null;
+  run_type?: string;
+  trigger_source?: string;
+  background?: boolean;
+  live_mode?: boolean;
+  attachment_ids?: string[];
+  [key: string]: any;
+}
+
+/**
+ * Client for the Glitch MCP paid facade (/mcp/v1).
+ *
+ * Authenticate with a Glitch user JWT or a title-scoped MCP token. The facade
+ * enforces subscription, title permissions, scope, and approval guardrails on
+ * every call; this client only forwards requests.
+ */
+class Mcp {
+  /** Health/auth probe. Returns authenticated=false (200) when no credential is set. */
+  public static authStatus<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.authStatus, {}, {}, params);
+  }
+
+  /** List titles visible to the current user token or title-scoped MCP token. */
+  public static listTitles<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.listTitles, {}, {}, params);
+  }
+
+  /** Fetch safe, subscription-gated workspace context for a title. */
+  public static titleContext<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.titleContext, {}, { title_id }, params);
+  }
+
+  /** Check subscription, trial, plan, and credit state for a title. */
+  public static billing<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.billing, {}, { title_id }, params);
+  }
+
+  /** Start a paid Glitch Agent run for a title. */
+  public static startRun<T>(title_id: string, data?: McpStartRunRequest, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.startRun, data ?? {}, { title_id }, params);
+  }
+
+  /** Fetch a durable run with status, actions, guidance, events, files, and report. */
+  public static viewRun<T>(title_id: string, run_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.viewRun, {}, { title_id, run_id }, params);
+  }
+
+  /** List user-visible timeline events for a run. */
+  public static runEvents<T>(title_id: string, run_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.runEvents, {}, { title_id, run_id }, params);
+  }
+
+  /** Fetch the human-friendly final or partial report for a run. */
+  public static finalReport<T>(title_id: string, run_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.finalReport, {}, { title_id, run_id }, params);
+  }
+
+  /**
+   * Server-Sent Events URL for a run's live event stream.
+   *
+   * Returns the absolute URL to open with an EventSource/fetch reader; the
+   * endpoint emits `status`, `run_event`, and a terminal `settled`/`timeout` event.
+   */
+  public static runStreamUrl(title_id: string, run_id: string, params?: Record<string, any>): string {
+    const url = McpRoute.routes.streamRun.url
+      .replace("{title_id}", encodeURIComponent(title_id))
+      .replace("{run_id}", encodeURIComponent(run_id));
+    return Requests.buildUrl(url, params);
+  }
+
+  /** List downloadable files and hosted report artifacts for a run. */
+  public static artifacts<T>(title_id: string, run_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.artifacts, {}, { title_id, run_id }, params);
+  }
+
+  /** List proposed/guidance/approval/executed actions for a title. */
+  public static listActions<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.listActions, {}, { title_id }, params);
+  }
+
+  /** Approve a reviewable action. Execution remains guarded server-side. */
+  public static approveAction<T>(title_id: string, action_id: string, data?: object, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.approveAction, data ?? {}, { title_id, action_id }, params);
+  }
+
+  /** Reject a proposed or approval-needed action. */
+  public static rejectAction<T>(title_id: string, action_id: string, data?: object, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.rejectAction, data ?? {}, { title_id, action_id }, params);
+  }
+
+  /** Execute an approved action. Public/paid/creator-facing work stays guarded. */
+  public static executeAction<T>(title_id: string, action_id: string, data?: object, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.executeAction, data ?? {}, { title_id, action_id }, params);
+  }
+
+  /** List open or answered guidance requests for a title or run. */
+  public static listGuidance<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.listGuidance, {}, { title_id }, params);
+  }
+
+  /** Answer a guidance request and resume the server-side workflow when possible. */
+  public static answerGuidance<T>(title_id: string, guidance_id: string, data?: object, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.answerGuidance, data ?? {}, { title_id, guidance_id }, params);
+  }
+
+  /** Get instructions for uploading a file (points at uploadFile below). */
+  public static createUpload<T>(title_id: string, data?: object, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.createUpload, data ?? {}, { title_id }, params);
+  }
+
+  /**
+   * Upload a file (image, video, or document) to a title or run as multipart/form-data.
+   * The facade re-checks the title scope, subscription, and allowed mime types.
+   */
+  public static uploadFile<T>(
+    title_id: string,
+    file: File | Blob,
+    data?: object,
+    params?: Record<string, any>,
+    onUploadProgress?: (progressEvent: AxiosProgressEvent) => void
+  ): AxiosPromise<Response<T>> {
+    const url = McpRoute.routes.uploadFile.url.replace("{title_id}", title_id);
+    return Requests.uploadFile(url, "file", file, data, params, onUploadProgress);
+  }
+
+  /** List MCP title tokens (user JWT only). */
+  public static listTokens<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.listTokens, {}, { title_id }, params);
+  }
+
+  /** Create a revocable title-scoped MCP token (user JWT only). */
+  public static createToken<T>(title_id: string, data?: object, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.createToken, data ?? {}, { title_id }, params);
+  }
+
+  /** Revoke a title-scoped MCP token (user JWT only). */
+  public static revokeToken<T>(title_id: string, token_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(McpRoute.routes.revokeToken, {}, { title_id, token_id }, params);
+  }
+}
+
+export default Mcp;

package/src/api/PrDirectory.ts

@@ -0,0 +1,440 @@
+import PrDirectoryRoutes from "../routes/PrDirectoryRoutes";
+import Requests from "../util/Requests";
+import Response from "../util/Response";
+import { AxiosPromise } from "axios";
+
+/**
+ * Allowed outlet types in the PR directory.
+ */
+export type PrPublicationType = "blog" | "podcast" | "publication";
+
+/**
+ * Eligibility state for a PR outlet.
+ */
+export type PrEligibilityStatus = "eligible" | "ineligible" | "needs_review" | "duplicate" | "archived";
+
+/**
+ * Verification state used by PR outlets, people, links, and contact points.
+ */
+export type PrVerificationStatus = "unverified" | "verified" | "stale" | "blocked" | "failed" | "needs_review";
+
+/**
+ * Email health status stored on the outlet-level PR email field.
+ */
+export type PrEmailStatus = "unknown" | "verified" | "bounced" | "missing" | "needs_review";
+
+/**
+ * Contact verification state for normalized contact points.
+ */
+export type PrContactVerificationStatus =
+  | "unverified"
+  | "verified"
+  | "stale"
+  | "bounced"
+  | "invalid"
+  | "blocked"
+  | "needs_review";
+
+/**
+ * Link refresh status for evidence URLs.
+ */
+export type PrLinkStatus = "unverified" | "ok" | "redirected" | "broken" | "blocked" | "failed" | "stale";
+
+/**
+ * Filters accepted by `/pr/publications` and `/pr/report`.
+ *
+ * Tag filters are human-readable slugs from `/pr/tags`. The backend accepts
+ * format, genre, platform, and audience as namespace-specific tag filters so
+ * frontend screens can expose simple controls without knowing pivot table
+ * details.
+ */
+export interface PrPublicationSearchParams {
+  q?: string;
+  type?: PrPublicationType;
+  eligibility_status?: PrEligibilityStatus;
+  verification_status?: PrVerificationStatus;
+  dedicated_to_gaming?: boolean;
+  has_email?: boolean;
+  country?: string;
+  language?: string;
+  canonical_domain?: string;
+  tag?: string;
+  format?: string;
+  genre?: string;
+  platform?: string;
+  audience?: string;
+  sort?: "name" | "-name" | "type" | "-type" | "eligibility_status" | "-eligibility_status" | "verification_status" | "-verification_status" | "last_verified_at" | "-last_verified_at" | "updated_at" | "-updated_at" | string;
+  page?: number;
+  per_page?: number;
+}
+
+/**
+ * Filters accepted by `/pr/people`.
+ */
+export interface PrPeopleSearchParams {
+  q?: string;
+  publication_id?: string;
+  role_category?: string;
+  is_active?: boolean;
+  verification_status?: PrVerificationStatus;
+  has_email?: boolean;
+  tag?: string;
+  role?: string;
+  sort?: "name" | "-name" | "verification_status" | "-verification_status" | "last_verified_at" | "-last_verified_at" | "updated_at" | "-updated_at" | string;
+  page?: number;
+  per_page?: number;
+}
+
+/**
+ * Filters accepted by `/pr/tags`.
+ */
+export interface PrTagSearchParams {
+  namespace?: string;
+  q?: string;
+}
+
+/**
+ * Query parameters accepted by `/titles/{title_id}/pr/matches`.
+ *
+ * The title matcher uses the title profile plus optional human-readable search
+ * context to rank eligible outlets and explain why each outlet is a fit.
+ */
+export interface PrTitleMatchParams extends PrPublicationSearchParams {
+  genres?: string[];
+  platforms?: string[];
+  audiences?: string[];
+  limit?: number;
+}
+
+/**
+ * Request body accepted by `/admin/pr/verification/queue`.
+ */
+export interface PrQueueVerificationRequest {
+  due?: boolean;
+  limit?: number;
+  link_ids?: string[];
+}
+
+/**
+ * A normalized metadata tag used to filter and match PR outlets, people, and
+ * roles.
+ */
+export interface PrTag {
+  id: string;
+  namespace: string;
+  slug: string;
+  label: string;
+  description?: string | null;
+  pivot?: {
+    confidence?: number | null;
+    source?: string | null;
+    source_link_id?: string | null;
+    verified_at?: string | null;
+    metadata?: Record<string, any> | null;
+  };
+  metadata?: Record<string, any>;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+/**
+ * A refreshable evidence URL that supports an outlet, person, role, or contact
+ * point.
+ */
+export interface PrLink {
+  id: string;
+  linkable_type?: string | null;
+  linkable_id?: string | null;
+  link_type: string;
+  url: string;
+  canonical_url?: string | null;
+  final_url?: string | null;
+  domain?: string | null;
+  priority: number;
+  http_status?: number | null;
+  status: PrLinkStatus;
+  content_type?: string | null;
+  content_hash?: string | null;
+  etag?: string | null;
+  last_modified_at?: string | null;
+  last_checked_at?: string | null;
+  next_check_at?: string | null;
+  last_error?: string | null;
+  is_source_of_truth: boolean;
+  metadata?: Record<string, any>;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+/**
+ * A normalized way to reach an outlet, person, or publication role.
+ */
+export interface PrContactPoint {
+  id: string;
+  contactable_type: string;
+  contactable_id: string;
+  pr_link_id?: string | null;
+  contact_type: "email" | "linkedin" | "x" | "bluesky" | "contact_form" | string;
+  label?: string | null;
+  value: string;
+  normalized_value: string;
+  verification_status: PrContactVerificationStatus;
+  confidence?: number | null;
+  is_primary: boolean;
+  first_seen_at?: string | null;
+  last_seen_at?: string | null;
+  source_link?: PrLink | null;
+  metadata?: Record<string, any>;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+/**
+ * The role a PR person has at one publication, blog, or podcast.
+ */
+export interface PublicationPerson {
+  id: string;
+  publication_id: string;
+  pr_person_id: string;
+  source_link_id?: string | null;
+  role_title?: string | null;
+  role_category?: string | null;
+  email?: string | null;
+  email_status: "unknown" | "verified" | "bounced" | "invalid" | "needs_review";
+  is_primary_contact: boolean;
+  is_current: boolean;
+  confidence?: number | null;
+  started_at?: string | null;
+  ended_at?: string | null;
+  last_verified_at?: string | null;
+  source_notes?: string | null;
+  person?: PrPerson | null;
+  publication?: PrPublication | null;
+  source_link?: PrLink | null;
+  contact_points?: PrContactPoint[];
+  tags?: PrTag[];
+  metadata?: Record<string, any>;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+/**
+ * A gaming-focused publication, independent blog, or podcast in the PR
+ * directory.
+ */
+export interface PrPublication {
+  id: string;
+  name: string;
+  slug?: string | null;
+  type: PrPublicationType;
+  url?: string | null;
+  canonical_domain?: string | null;
+  description?: string | null;
+  main_pr_email?: string | null;
+  main_pr_email_status: PrEmailStatus;
+  dedicated_to_gaming: boolean;
+  eligibility_status: PrEligibilityStatus;
+  exclusion_reason?: string | null;
+  language?: string | null;
+  country?: string | null;
+  network_or_owner?: string | null;
+  verification_status: PrVerificationStatus;
+  last_verified_at?: string | null;
+  next_verification_at?: string | null;
+  source_imported_at?: string | null;
+  people_count?: number;
+  contact_points_count?: number;
+  links_count?: number;
+  people?: PublicationPerson[];
+  contact_points?: PrContactPoint[];
+  links?: PrLink[];
+  tags?: PrTag[];
+  metadata?: Record<string, any>;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+/**
+ * A journalist, editor, podcast host, producer, contributor, or other PR
+ * contact associated with one or more gaming-focused outlets.
+ */
+export interface PrPerson {
+  id: string;
+  name: string;
+  slug?: string | null;
+  bio?: string | null;
+  location?: string | null;
+  linkedin_url?: string | null;
+  x_url?: string | null;
+  bluesky_url?: string | null;
+  website_url?: string | null;
+  is_active: boolean;
+  verification_status: PrVerificationStatus;
+  last_verified_at?: string | null;
+  next_verification_at?: string | null;
+  roles_count?: number;
+  contact_points_count?: number;
+  links_count?: number;
+  roles?: PublicationPerson[];
+  contact_points?: PrContactPoint[];
+  links?: PrLink[];
+  tags?: PrTag[];
+  metadata?: Record<string, any>;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+/**
+ * Aggregate PR directory health metrics returned by `/pr/report`.
+ */
+export interface PrDirectoryReport {
+  generated_at: string;
+  publications: {
+    total: number;
+    by_type: Record<string, number>;
+    by_eligibility_status: Record<string, number>;
+    by_verification_status: Record<string, number>;
+    dedicated_to_gaming: number;
+    with_email: number;
+    due_for_verification: number;
+  };
+  people: {
+    total: number;
+    active: number;
+    with_email: number;
+    by_verification_status: Record<string, number>;
+  };
+  links: {
+    total: number;
+    by_type: Record<string, number>;
+    by_status: Record<string, number>;
+    due_for_check: number;
+  };
+  contacts: {
+    total: number;
+    by_type: Record<string, number>;
+    by_status: Record<string, number>;
+  };
+  tags: {
+    total: number;
+    by_namespace: Record<string, number>;
+  };
+}
+
+/**
+ * A ranked title-to-outlet match with evidence, contact route, and plain-English
+ * explanation.
+ */
+export interface PrTitleMatch {
+  publication: PrPublication;
+  score: number;
+  matched_tags: string[];
+  best_contact_path?: Record<string, any> | null;
+  why: string[];
+  risks: string[];
+  evidence_links: PrLink[];
+}
+
+/**
+ * Response body returned after queueing PR verification jobs.
+ */
+export interface PrQueueVerificationResponse {
+  queued: number;
+}
+
+/**
+ * SDK wrapper for the PR Directory API.
+ *
+ * The PR directory is read-friendly by default: public endpoints expose
+ * searchable publications, people, tags, and reporting metrics. Authenticated
+ * title admins can request title-specific PR matches, and site admins can queue
+ * monthly-style verification jobs.
+ */
+class PrDirectory {
+  /**
+   * Search gaming-focused PR publications, independent blogs, and podcasts.
+   *
+   * @example
+   * ```ts
+   * Glitch.api.PrDirectory.listPublications({
+   *   q: "indie RPG",
+   *   has_email: true,
+   *   eligibility_status: "eligible",
+   *   sort: "-last_verified_at",
+   * });
+   * ```
+   */
+  public static listPublications<T = PrPublication[]>(params?: PrPublicationSearchParams): AxiosPromise<Response<T>> {
+    return Requests.processRoute(PrDirectoryRoutes.routes.listPublications, {}, {}, params);
+  }
+
+  /**
+   * Retrieve one PR publication profile with loaded people, contact points,
+   * evidence links, and tags.
+   */
+  public static viewPublication<T = PrPublication>(publication_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(PrDirectoryRoutes.routes.viewPublication, {}, { publication_id }, params);
+  }
+
+  /**
+   * Search PR people and roles across all known publications.
+   *
+   * @example
+   * ```ts
+   * Glitch.api.PrDirectory.listPeople({
+   *   q: "reviews editor",
+   *   has_email: true,
+   *   role_category: "editor",
+   * });
+   * ```
+   */
+  public static listPeople<T = PrPerson[]>(params?: PrPeopleSearchParams): AxiosPromise<Response<T>> {
+    return Requests.processRoute(PrDirectoryRoutes.routes.listPeople, {}, {}, params);
+  }
+
+  /**
+   * Retrieve one PR person profile with their outlet roles, profile links,
+   * contact points, and metadata tags.
+   */
+  public static viewPerson<T = PrPerson>(person_id: string, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(PrDirectoryRoutes.routes.viewPerson, {}, { person_id }, params);
+  }
+
+  /**
+   * List the normalized tag vocabulary used for PR search, filters, matching,
+   * and reporting.
+   */
+  public static listTags<T = PrTag[]>(params?: PrTagSearchParams): AxiosPromise<Response<T>> {
+    return Requests.processRoute(PrDirectoryRoutes.routes.listTags, {}, {}, params);
+  }
+
+  /**
+   * Get aggregate PR directory reporting metrics. Publication filters can be
+   * supplied to scope the outlet portion of the report.
+   */
+  public static report<T = PrDirectoryReport>(params?: PrPublicationSearchParams): AxiosPromise<Response<T>> {
+    return Requests.processRoute(PrDirectoryRoutes.routes.report, {}, {}, params);
+  }
+
+  /**
+   * Match a registered game title to PR outlets. Requires an auth token for a
+   * user who can administer the requested title.
+   */
+  public static titleMatches<T = PrTitleMatch[]>(title_id: string, params?: PrTitleMatchParams): AxiosPromise<Response<T>> {
+    return Requests.processRoute(PrDirectoryRoutes.routes.titleMatches, {}, { title_id }, params);
+  }
+
+  /**
+   * Queue PR verification jobs. Requires a site-admin auth token.
+   *
+   * @example
+   * ```ts
+   * Glitch.api.PrDirectory.queueVerification({ due: true, limit: 250 });
+   * ```
+   */
+  public static queueVerification<T = PrQueueVerificationResponse>(data?: PrQueueVerificationRequest, params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(PrDirectoryRoutes.routes.queueVerification, data || {}, {}, params);
+  }
+}
+
+export default PrDirectory;

package/src/api/Users.ts

@@ -256,6 +256,18 @@ class Users {
         return Requests.processRoute(UserRoutes.routes.clearGoogleAuth, {});
     }
 
+    /**
+     * Clear Gmail Workspace authentication information from the current user.
+     *
+     * @see https://api.glitch.fun/api/documentation#/Users%20Route/clearGmailAuth
+     *
+     * @returns promise
+     */
+    public static clearGmailAuth<T>(): AxiosPromise<Response<T>> {
+
+        return Requests.processRoute(UserRoutes.routes.clearGmailAuth, {});
+    }
+
     /**
      * Clear Stripe authentication information from the current user.
      * 
@@ -699,4 +711,4 @@ class Users {
 
 }
 
-export default Users;
+export default Users;

package/src/api/index.ts

@@ -46,6 +46,8 @@ import Crm from "./Crm";
 import Multiplayer from "./Multiplayer";
 import ServerOperations from "./ServerOperations";
 import Agents from "./Agents";
+import Mcp from "./Mcp";
+import PrDirectory from "./PrDirectory";
 
 export {Ads};
 export {AccessKeys};
@@ -95,3 +97,5 @@ export {Crm};
 export {Multiplayer};
 export {ServerOperations};
 export {Agents};
+export {Mcp};
+export {PrDirectory};

package/src/index.ts

@@ -50,6 +50,8 @@ import {Crm} from './api';
 import {Multiplayer} from './api';
 import {ServerOperations} from './api';
 import {Agents} from './api';
+import {Mcp} from './api';
+import {PrDirectory} from './api';
 
 import Requests from "./util/Requests";
 import Parser from "./util/Parser";
@@ -129,6 +131,8 @@ class Glitch {
         Multiplayer : Multiplayer,
         ServerOperations : ServerOperations,
         Agents : Agents,
+        Mcp : Mcp,
+        PrDirectory : PrDirectory,
     }
 
     public static util = {

package/src/models/user.ts

@@ -23,9 +23,18 @@ interface User {
     twitch_handle?: string;
     youtube_handle?: string;
     paetron_handle?: string;
+    gmail_oauth_token?: string;
+    gmail_refresh_token?: string;
+    gmail_token_expiration?: number;
+    gmail_token_expires_at?: string;
+    gmail_id?: string;
+    gmail_name?: string;
+    gmail_email?: string;
+    gmail_avatar?: string;
+    gmail_scopes?: string[];
+    gmail_connected_at?: string;
     created_at?: string;
     updated_at?: string;
   }
 
   export default User;
-  

package/src/routes/AgentsRoute.ts

@@ -25,6 +25,7 @@ class AgentsRoute {
     executeAction: { url: "/agents/titles/{title_id}/actions/{action_id}/execute", method: HTTP_METHODS.POST },
     listGuidance: { url: "/agents/titles/{title_id}/guidance", method: HTTP_METHODS.GET },
     answerGuidance: { url: "/agents/titles/{title_id}/guidance/{guidance_id}/answer", method: HTTP_METHODS.POST },
+    rewriteAgentDraft: { url: "/agents/titles/{title_id}/drafts/rewrite", method: HTTP_METHODS.POST },
     listMemories: { url: "/agents/titles/{title_id}/memories", method: HTTP_METHODS.GET },
     results: { url: "/agents/titles/{title_id}/results", method: HTTP_METHODS.GET },
     usage: { url: "/agents/titles/{title_id}/usage", method: HTTP_METHODS.GET },