@hallofame/cloudflare-agent 0.1.15 → 0.1.17

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

package/package.json

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

package/src/HallOfFameAgent.ts

@@ -12,6 +12,7 @@ const TOKEN_KEY = 'halloffame-token'
 const DEFAULT_MODEL = '@cf/google/gemma-4-26b-a4b-it'
 const DEFAULT_INTERVAL_SECONDS = 18_000
 const MAX_TOOL_STEPS = 12
+const MAX_EMPTY_MODEL_RETRIES = 2
 const MAX_REQUEST_FAILURES = 20
 
 type ModelMessage = Record<string, unknown>
@@ -103,7 +104,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':
@@ -118,6 +124,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 })
@@ -156,6 +175,59 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
     return { authenticated: true, account: this.withoutToken(response) }
   }
 
+  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 }> {
     await this.login()
 
@@ -193,18 +265,8 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
 
     try {
       for (let step = 0; step < MAX_TOOL_STEPS; step += 1) {
-        const input = {
-          messages,
-          tools,
-          max_tokens: 1024,
-          ...(visionImage ? { image: visionImage } : {}),
-        }
+        const result = await this.requestModel(messages, visionImage)
         visionImage = undefined
-        const rawResult = await this.env.AI.run(
-          (this.env.HOF_MODEL ?? DEFAULT_MODEL) as keyof AiModels,
-          input as never,
-        )
-        const result = new WorkersAIResponse(rawResult).normalize()
         const calls = this.parseToolCalls(result.toolCalls)
 
         if (calls.length === 0) {
@@ -258,6 +320,39 @@ export class HallOfFameAgent extends Agent<Env, AgentState> {
     }
   }
 
+  private async requestModel(
+    messages: ModelMessage[],
+    visionImage?: string,
+  ): Promise<ReturnType<WorkersAIResponse['normalize']>> {
+    for (let attempt = 0; attempt <= MAX_EMPTY_MODEL_RETRIES; attempt += 1) {
+      const retryInstruction =
+        attempt > 0
+          ? [
+              {
+                role: 'system',
+                content:
+                  'The previous model turn was empty. Continue from the existing conversation. Return the required tool call, or a concise factual final response if the task is complete.',
+              },
+            ]
+          : []
+      const rawResult = await this.env.AI.run(
+        (this.env.HOF_MODEL ?? DEFAULT_MODEL) as keyof AiModels,
+        {
+          messages: [...messages, ...retryInstruction],
+          tools,
+          max_tokens: 1024,
+          ...(visionImage ? { image: visionImage } : {}),
+        } as never,
+      )
+      const result = new WorkersAIResponse(rawResult).normalize()
+      if (result.text || result.toolCalls.length > 0) return result
+    }
+
+    throw new Error(
+      `Workers AI returned neither text nor tool calls after ${MAX_EMPTY_MODEL_RETRIES + 1} attempts.`,
+    )
+  }
+
   private async executeTool(
     call: ToolCall,
     token: string,

package/src/WorkersAIResponse.ts

@@ -7,10 +7,12 @@ export class WorkersAIResponse {
   constructor(private readonly value: unknown) {}
 
   normalize(): NormalizedModelResponse {
-    const result = this.record(this.value)
+    const envelope = this.record(this.value)
+    const nested = this.record(envelope.result)
+    const result = Object.keys(nested).length > 0 ? nested : envelope
     const choice = Array.isArray(result.choices) ? this.record(result.choices[0]) : {}
     const message = this.record(choice.message)
-    const content = result.response ?? message.content
+    const content = result.response ?? result.output_text ?? message.content
 
     return {
       text: this.text(content),