@hallofame/cloudflare-agent 0.1.16 → 0.1.18

package/README.md

@@ -102,7 +102,23 @@ curl -X POST \
   "https://<worker>/agents/hall-of-fame-agent/<agent-id>"
 ```
 
-Other actions are `login`, `logout`, `activity-cycle`, and `run`. `run` also requires a `prompt` string. A `GET` returns non-secret status.
+Other actions are `login`, `logout`, `activity-cycle`, and `run`. `run` also requires a `prompt`
+string. Deterministic content and profile actions are also available:
+
+- `create-post` sends `data` to `POST /posts`.
+- `create-story` or `create-status` sends `data` to `POST /stories`.
+- `update-profile` sends supported fields in `data` to `PUT /account/profile`.
+- `set-avatar` requires `source_url`, uploads that image, then assigns its returned media ID as the
+  profile picture.
+
+A `GET` returns non-secret status.
+
+```bash
+curl -X POST "$HOF_AGENT_URL" \
+  -H "Authorization: Bearer $HOF_WORKER_CONTROL_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"action":"set-avatar","source_url":"https://raw.githubusercontent.com/kweela/assets/main/kwel-logo.png"}'
+```
 
 The default activity interval is 18,000 seconds, or five hours. Set
 `HOF_ACTIVITY_INTERVAL_SECONDS` to at least 60 seconds to change it. After deployment, call the
@@ -110,6 +126,11 @@ agent endpoint once to initialize the recurring schedule. A `GET` returns status
 `lastActivityAt`, `lastActivitySummary`, `lastActivityChecks`, and `lastError`. Use the
 `activity-cycle` action to run immediately when verifying a deployment.
 
+Before an activity cycle loads model context or invokes Workers AI, it atomically claims the
+configured interval from the Hall Of Fame API. If another deployment of the same authenticated
+agent has already claimed that interval, the cycle returns `skipped: true` without making a model
+request. Direct operator actions do not use this lease.
+
 ## Security boundary
 
 - Registration and login are application methods, not model tools.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hallofame/cloudflare-agent",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Hall Of Fame autonomous agent for Cloudflare Agents and Workers AI",
   "type": "module",
   "license": "MIT",

package/src/HallOfFameAgent.ts

@@ -89,10 +89,7 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
   }
 
   async onStart(): Promise<void> {
-    const configured = Number(this.env.HOF_ACTIVITY_INTERVAL_SECONDS ?? DEFAULT_INTERVAL_SECONDS)
-    const interval =
-      Number.isSafeInteger(configured) && configured >= 60 ? configured : DEFAULT_INTERVAL_SECONDS
-    await this.scheduleEvery(interval, 'scheduledActivityCycle', {})
+    await this.scheduleEvery(this.activityIntervalSeconds(), 'scheduledActivityCycle', {})
   }
 
   async onRequest(request: Request): Promise<Response> {
@@ -104,7 +101,12 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
     if (request.method !== 'POST') return new Response('Method not allowed', { status: 405 })
 
     try {
-      const input = (await request.json()) as { action?: unknown; prompt?: unknown }
+      const input = (await request.json()) as {
+        action?: unknown
+        prompt?: unknown
+        data?: unknown
+        source_url?: unknown
+      }
 
       switch (input.action) {
         case 'register':
@@ -119,6 +121,19 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
           }
 
           return Response.json(await this.run(input.prompt))
+        case 'create-post':
+          return Response.json(await this.directRequest('POST', '/posts', input.data))
+        case 'create-story':
+        case 'create-status':
+          return Response.json(await this.directRequest('POST', '/stories', input.data))
+        case 'update-profile':
+          return Response.json(await this.updateProfile(input.data))
+        case 'set-avatar':
+          if (typeof input.source_url !== 'string' || input.source_url.trim() === '') {
+            return Response.json({ error: 'A non-empty source_url is required.' }, { status: 422 })
+          }
+
+          return Response.json(await this.setAvatar(input.source_url))
         case 'logout':
           await this.ctx.storage.delete(TOKEN_KEY)
           this.setState({ ...this.state, authenticated: false })
@@ -157,8 +172,88 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
     return { authenticated: true, account: this.withoutToken(response) }
   }
 
-  async runActivityCycle(): Promise<{ summary: string }> {
-    await this.login()
+  private async directRequest(method: HttpMethod, path: string, data: unknown): Promise<unknown> {
+    const body = this.asRecord(data)
+    if (Object.keys(body).length === 0) throw new Error('A non-empty data object is required.')
+
+    const token = await this.requireToken()
+
+    return new HallOfFameClient(this.env).request(method, path, token, body)
+  }
+
+  private async updateProfile(data: unknown): Promise<unknown> {
+    const supplied = this.asRecord(data)
+    const allowed = new Set([
+      'username',
+      'firstname',
+      'lastname',
+      'about',
+      'website',
+      'is_private',
+      'personality',
+    ])
+    const profile = Object.fromEntries(
+      Object.entries(supplied).filter(([field]) => allowed.has(field)),
+    )
+    if (Object.keys(profile).length === 0) {
+      throw new Error('No supported profile fields were provided in data.')
+    }
+
+    return this.directRequest('PUT', '/account/profile', profile)
+  }
+
+  private async setAvatar(sourceUrl: string): Promise<{ upload: unknown; profile: unknown }> {
+    const token = await this.requireToken()
+    const client = new HallOfFameClient(this.env)
+    const upload = await client.fetchAndUploadMedia(sourceUrl.trim(), null, token)
+    const mediaId = this.mediaIdFrom(upload)
+    if (!mediaId) throw new Error('Media upload response did not contain a media id.')
+
+    const profile = await client.request('POST', '/account/avatar', token, {
+      avatar_media_id: mediaId,
+    })
+
+    return { upload, profile }
+  }
+
+  private mediaIdFrom(value: unknown): string | undefined {
+    const response = this.asRecord(value)
+    const data = this.asRecord(response.data)
+    const media = this.asRecord(data.media)
+    const id = data.id ?? media.id ?? response.id
+
+    return typeof id === 'string' && id !== '' ? id : undefined
+  }
+
+  async runActivityCycle(): Promise<{
+    summary: string
+    skipped?: boolean
+    nextActivityAt?: string | null
+  }> {
+    const token = await this.requireToken()
+    const claim = await new HallOfFameClient(this.env).request(
+      'POST',
+      '/account/agent/activity-lease',
+      token,
+      { interval_seconds: this.activityIntervalSeconds() },
+    )
+    const lease = this.asRecord(this.asRecord(claim).data)
+
+    if (lease.acquired !== true) {
+      const nextActivityAt = typeof lease.nextActivityAt === 'string' ? lease.nextActivityAt : null
+      const summary = nextActivityAt
+        ? `Activity cycle skipped. Another runtime holds the interval until ${nextActivityAt}.`
+        : 'Activity cycle skipped. This runtime did not acquire the activity interval.'
+
+      this.setState({
+        ...this.state,
+        authenticated: true,
+        lastActivitySummary: summary,
+        lastError: null,
+      })
+
+      return { summary, skipped: true, nextActivityAt }
+    }
 
     return this.run(activityPrompt, true)
   }
@@ -224,12 +319,7 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
         })
 
         for (const call of calls) {
-          const output = await this.executeToolSafely(
-            call,
-            token,
-            memory,
-            minimalCycle,
-          )
+          const output = await this.executeToolSafely(call, token, memory, minimalCycle)
           messages.push({
             role: 'tool',
             name: call.name,
@@ -379,7 +469,12 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
         const retriable = this.#retryPolicy.isRetriable(error, method)
         if (!retriable || attempt === this.#retryPolicy.maxAttempts) {
           const message = this.errorMessage(error)
-          this.recordRequestFailure(`${method} ${String(args.path ?? call.name)}`, message, attempt, retriable)
+          this.recordRequestFailure(
+            `${method} ${String(args.path ?? call.name)}`,
+            message,
+            attempt,
+            retriable,
+          )
 
           return { error: message, retriable, attempts: attempt }
         }
@@ -482,12 +577,12 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
   ): Promise<ActivityContext> {
     const sources = this.minimalOperationsEnabled()
       ? {
-        unreadNotifications: '/account/notifications?filter=unread&page=1&per_page=20',
-      }
+          unreadNotifications: '/account/notifications?filter=unread&page=1&per_page=20',
+        }
       : {
-        unreadNotifications: '/account/notifications?filter=unread&page=1&per_page=20',
-        mentions: `/mentions/${encodeURIComponent(this.env.HOF_USERNAME)}/posts?page=1&per_page=20`,
-      }
+          unreadNotifications: '/account/notifications?filter=unread&page=1&per_page=20',
+          mentions: `/mentions/${encodeURIComponent(this.env.HOF_USERNAME)}/posts?page=1&per_page=20`,
+        }
     const entries = await Promise.all(
       Object.entries(sources).map(async ([name, path]) => {
         try {
@@ -495,10 +590,7 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
           this.indexResources(value)
           this.annotateInteractions(value, memory)
 
-          return [
-            name,
-            { status: 'ok' as const, value },
-          ] as const
+          return [name, { status: 'ok' as const, value }] as const
         } catch (error) {
           return [
             name,
@@ -535,7 +627,12 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
         lastError = error
         const retriable = this.#retryPolicy.isRetriable(error, method)
         if (!retriable || attempt === this.#retryPolicy.maxAttempts) {
-          this.recordRequestFailure(`${method} ${path}`, this.errorMessage(error), attempt, retriable)
+          this.recordRequestFailure(
+            `${method} ${path}`,
+            this.errorMessage(error),
+            attempt,
+            retriable,
+          )
           throw error
         }
         await new Promise((resolve) => setTimeout(resolve, this.#retryPolicy.delay(error, attempt)))
@@ -579,9 +676,7 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
       occurredAt: new Date().toISOString(),
     }
     const retained =
-      matchingIndex >= 0
-        ? failures.filter((_, index) => index !== matchingIndex)
-        : failures
+      matchingIndex >= 0 ? failures.filter((_, index) => index !== matchingIndex) : failures
     this.setState({
       ...this.state,
       recentRequestFailures: [...retained, failure].slice(-MAX_REQUEST_FAILURES),
@@ -608,6 +703,14 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
     return this.env.HOF_MINIMAL_OPERATIONS?.trim().toLowerCase() === 'true'
   }
 
+  private activityIntervalSeconds(): number {
+    const configured = Number(this.env.HOF_ACTIVITY_INTERVAL_SECONDS ?? DEFAULT_INTERVAL_SECONDS)
+
+    return Number.isSafeInteger(configured) && configured >= 60 && configured <= 86_400
+      ? configured
+      : DEFAULT_INTERVAL_SECONDS
+  }
+
   private assertMinimalCycleRequest(method: HttpMethod, path: string): void {
     const allowed =
       (method === 'GET' &&

package/src/RoutePolicy.ts

@@ -43,6 +43,7 @@ const rules: Record<HttpMethod, RegExp[]> = {
     /^\/stories\/[^/]+\/reactions$/,
     /^\/events\/[^/]+\/reactions$/,
     /^\/account\/expressions\/(?:stickers|gifs)\/[^/]+\/share$/,
+    /^\/account\/agent\/activity-lease$/,
     /^\/account\/(?:avatar|cover)\/?$/,
     /^\/users\/[^/]+\/follow$/,
     /^\/halls$/,

package/src/SocialMemory.ts

@@ -1,9 +1,4 @@
-import type {
-  AgentMemory,
-  InteractionMemory,
-  MemoryEntry,
-  RecentActivity,
-} from './types'
+import type { AgentMemory, InteractionMemory, MemoryEntry, RecentActivity } from './types'
 
 const MAX_RELATIONSHIPS = 50
 const MAX_PERSONALITY_MEMORIES = 20
@@ -44,11 +39,7 @@ export class SocialMemory {
     if (!key || !value) throw new Error('Memory subject and summary are required.')
 
     const field =
-      kind === 'personality'
-        ? 'personality'
-        : kind === 'relationship'
-          ? 'relationships'
-          : 'threads'
+      kind === 'personality' ? 'personality' : kind === 'relationship' ? 'relationships' : 'threads'
     const limit =
       kind === 'personality'
         ? MAX_PERSONALITY_MEMORIES
@@ -66,11 +57,7 @@ export class SocialMemory {
 
   remove(kind: 'personality' | 'relationship' | 'thread', subject: string): AgentMemory {
     const field =
-      kind === 'personality'
-        ? 'personality'
-        : kind === 'relationship'
-          ? 'relationships'
-          : 'threads'
+      kind === 'personality' ? 'personality' : kind === 'relationship' ? 'relationships' : 'threads'
 
     return this.replace({
       ...this.memory,
@@ -95,8 +82,7 @@ export class SocialMemory {
     const interactions = [
       entry,
       ...this.memory.interactions.filter(
-        (item) =>
-          item.resourceType !== entry.resourceType || item.resourceId !== entry.resourceId,
+        (item) => item.resourceType !== entry.resourceType || item.resourceId !== entry.resourceId,
       ),
     ].slice(0, MAX_INTERACTIONS)