crawd 0.8.6 → 0.9.0

package/src/plugin.ts

@@ -7,7 +7,7 @@
  * - `crawd` service (Fastify + Socket.IO backend)
  */
 import { Type } from '@sinclair/typebox'
-import { CrawdBackend, type CrawdConfig, type TtsVoiceEntry } from './backend/server.js'
+import { CrawdBackend, type CrawdConfig } from './backend/server.js'
 
 // Minimal plugin types — the real types come from openclaw/plugin-sdk at runtime.
 // Defined inline so this package builds without the openclaw peerDep installed.
@@ -36,18 +36,6 @@ type PluginDefinition = {
 // Config parsing — transform pluginConfig → CrawdConfig
 // ---------------------------------------------------------------------------
 
-function parseTtsChain(raw: unknown): TtsVoiceEntry[] {
-  if (!Array.isArray(raw)) return []
-  return raw
-    .filter((e): e is { provider: string; voice: string } =>
-      e && typeof e === 'object' && typeof e.provider === 'string' && typeof e.voice === 'string',
-    )
-    .map((e) => ({
-      provider: e.provider as TtsVoiceEntry['provider'],
-      voice: e.voice,
-    }))
-}
-
 /** Resolve gateway WebSocket URL from env/defaults (same logic as OpenClaw's callGateway) */
 function resolveGatewayUrl(port?: number): string {
   if (port) return `ws://127.0.0.1:${port}`
@@ -74,7 +62,6 @@ function resolveGatewayFromHost(api: PluginApi): { token?: string; port?: number
 
 function parsePluginConfig(raw: Record<string, unknown> | undefined): CrawdConfig {
   const cfg = raw ?? {}
-  const tts = (cfg.tts ?? {}) as Record<string, unknown>
   const vibe = (cfg.vibe ?? {}) as Record<string, unknown>
   const chat = (cfg.chat ?? {}) as Record<string, unknown>
   const youtube = (chat.youtube ?? {}) as Record<string, unknown>
@@ -86,19 +73,12 @@ function parsePluginConfig(raw: Record<string, unknown> | undefined): CrawdConfi
     enabled: cfg.enabled !== false,
     port,
     bindHost: typeof cfg.bindHost === 'string' ? cfg.bindHost : '0.0.0.0',
-    backendUrl: typeof cfg.backendUrl === 'string' ? cfg.backendUrl : `http://localhost:${port}`,
-    tts: {
-      chat: parseTtsChain(tts.chat),
-      bot: parseTtsChain(tts.bot),
-      openaiApiKey: typeof tts.openaiApiKey === 'string' ? tts.openaiApiKey : undefined,
-      elevenlabsApiKey: typeof tts.elevenlabsApiKey === 'string' ? tts.elevenlabsApiKey : undefined,
-      tiktokSessionId: typeof tts.tiktokSessionId === 'string' ? tts.tiktokSessionId : undefined,
-    },
     vibe: {
       enabled: vibe.enabled !== false,
       intervalMs: typeof vibe.intervalMs === 'number' ? vibe.intervalMs : 10_000,
       idleAfterMs: typeof vibe.idleAfterMs === 'number' ? vibe.idleAfterMs : 30_000,
       sleepAfterIdleMs: typeof vibe.sleepAfterIdleMs === 'number' ? vibe.sleepAfterIdleMs : 60_000,
+      batchWindowMs: typeof vibe.batchWindowMs === 'number' ? vibe.batchWindowMs : 20_000,
       prompt: typeof vibe.prompt === 'string' ? vibe.prompt : undefined,
     },
     chat: {
@@ -112,6 +92,10 @@ function parsePluginConfig(raw: Record<string, unknown> | undefined): CrawdConfi
         authToken: typeof pumpfun.authToken === 'string' ? pumpfun.authToken : undefined,
       },
     },
+    // Autonomy mode: vibe (periodic prompts), plan (goal-driven), none (disabled)
+    autonomyMode: cfg.autonomyMode === 'vibe' || cfg.autonomyMode === 'plan' || cfg.autonomyMode === 'none'
+      ? cfg.autonomyMode
+      : undefined,
     // Gateway: plugin config overrides, then env vars, then OpenClaw defaults
     gatewayUrl: typeof cfg.gatewayUrl === 'string' ? cfg.gatewayUrl
       : process.env.OPENCLAW_GATEWAY_URL ?? resolveGatewayUrl(),
@@ -135,31 +119,27 @@ const crawdConfigSchema = {
     enabled: { label: 'Enabled' },
     port: { label: 'Backend Port', placeholder: '4000' },
     bindHost: { label: 'Bind Host', placeholder: '0.0.0.0', advanced: true },
-    backendUrl: { label: 'Backend URL', advanced: true, help: 'Public URL for TTS file serving' },
-    'tts.chat': { label: 'Chat TTS Voices', help: 'Ordered fallback chain [{provider, voice}]' },
-    'tts.bot': { label: 'Bot TTS Voices', help: 'Ordered fallback chain [{provider, voice}]' },
-    'tts.openaiApiKey': { label: 'OpenAI API Key', sensitive: true },
-    'tts.elevenlabsApiKey': { label: 'ElevenLabs API Key', sensitive: true },
-    'tts.tiktokSessionId': { label: 'TikTok Session ID', sensitive: true },
+    'autonomyMode': { label: 'Autonomy Mode', help: 'vibe = timed prompts, plan = goal-driven loop, none = disabled' },
     'vibe.enabled': { label: 'Vibe Mode' },
     'vibe.intervalMs': { label: 'Vibe Interval (ms)', advanced: true },
     'vibe.idleAfterMs': { label: 'Idle After (ms)', advanced: true },
     'vibe.sleepAfterIdleMs': { label: 'Sleep After Idle (ms)', advanced: true },
+    'vibe.batchWindowMs': { label: 'Chat Batch Window (ms)', advanced: true },
     'vibe.prompt': { label: 'Vibe Prompt', advanced: true },
     'chat.youtube.enabled': { label: 'YouTube Chat' },
     'chat.youtube.videoId': { label: 'YouTube Video ID' },
     'chat.pumpfun.enabled': { label: 'PumpFun Chat' },
     'chat.pumpfun.tokenMint': { label: 'PumpFun Token Mint' },
     'chat.pumpfun.authToken': { label: 'PumpFun Auth Token', sensitive: true },
-    gatewayUrl: { label: 'Gateway URL', advanced: true, help: 'Override auto-detected gateway URL (usually not needed)' },
-    gatewayToken: { label: 'Gateway Token', advanced: true, sensitive: true, help: 'Override OPENCLAW_GATEWAY_TOKEN env var' },
+    gatewayUrl: { label: 'Gateway URL', help: 'WebSocket URL for agent triggering', advanced: true },
+    gatewayToken: { label: 'Gateway Token', sensitive: true },
   },
 }
 
 const plugin: PluginDefinition = {
   id: 'crawd',
   name: 'Crawd Livestream',
-  description: 'crawd.bot plugin — AI agent livestreaming with TTS, chat integration, and OBS overlay',
+  description: 'crawd.bot plugin — AI agent livestreaming with chat integration and OBS overlay',
   configSchema: crawdConfigSchema,
 
   register(api: PluginApi) {
@@ -207,7 +187,7 @@ const plugin: PluginDefinition = {
         name: 'livestream_talk',
         label: 'Livestream Talk',
         description:
-          'Speak on the livestream unprompted. Shows a speech bubble on the overlay and generates TTS audio. Use for narration, vibes, and commentary — NOT for replying to chat (use livestream_reply for that).',
+          'Speak on the livestream unprompted. Shows a speech bubble on the overlay. Use for narration, vibes, and commentary — NOT for replying to chat (use livestream_reply for that).',
         parameters: Type.Object({
           text: Type.String({ description: 'Message to speak on stream' }),
         }),
@@ -230,7 +210,7 @@ const plugin: PluginDefinition = {
         name: 'livestream_reply',
         label: 'Livestream Reply',
         description:
-          'Reply to a chat message on the livestream. Reads the original message aloud with the chat voice, then speaks your reply with the bot voice. Use this ONLY when responding to a specific viewer message.',
+          'Reply to a chat message on the livestream. Shows the original message and your reply on the overlay. Use this ONLY when responding to a specific viewer message.',
         parameters: Type.Object({
           text: Type.String({ description: 'Your reply to the chat message' }),
           username: Type.String({ description: 'Username of the person you are replying to' }),
@@ -249,6 +229,117 @@ const plugin: PluginDefinition = {
       { name: 'livestream_reply' },
     )
 
+    // plan_set — create or replace current plan
+    api.registerTool(
+      {
+        name: 'plan_set',
+        label: 'Set Plan',
+        description:
+          'Create or replace the current plan. Provide a goal and ordered steps. Any existing active plan is abandoned.',
+        parameters: Type.Object({
+          goal: Type.String({ description: 'The overall goal of the plan' }),
+          steps: Type.Array(Type.String(), { description: 'Ordered list of steps to accomplish the goal', minItems: 1, maxItems: 20 }),
+        }),
+        async execute(_toolCallId: string, params: unknown) {
+          const b = await ensureBackend()
+          const { goal, steps } = params as { goal: string; steps: string[] }
+          const result = b.setPlan(goal, steps)
+          if ('error' in result) {
+            return { content: [{ type: 'text', text: `Failed: ${result.error}` }] }
+          }
+          const stepList = result.plan.steps.map((s, i) => `  ${i}. ${s.description}`).join('\n')
+          return {
+            content: [{ type: 'text', text: `Plan created: ${goal}\n${stepList}` }],
+            details: result,
+          }
+        },
+      },
+      { name: 'plan_set' },
+    )
+
+    // plan_step_done — mark a step as complete
+    api.registerTool(
+      {
+        name: 'plan_step_done',
+        label: 'Plan Step Done',
+        description:
+          'Mark a plan step as done by its 0-based index. The coordinator will nudge you for the next step.',
+        parameters: Type.Object({
+          step: Type.Number({ description: 'Zero-based index of the step to mark as done' }),
+        }),
+        async execute(_toolCallId: string, params: unknown) {
+          const b = await ensureBackend()
+          const { step } = params as { step: number }
+          const result = b.markPlanStepDone(step)
+          if ('error' in result) {
+            return { content: [{ type: 'text', text: `Failed: ${result.error}` }] }
+          }
+          const done = result.plan.steps.filter(s => s.status === 'done').length
+          const total = result.plan.steps.length
+          const isComplete = result.plan.status === 'completed'
+          return {
+            content: [{ type: 'text', text: isComplete
+              ? `Plan completed! All ${total} steps done.`
+              : `Step ${step} done (${done}/${total} complete).`
+            }],
+            details: result,
+          }
+        },
+      },
+      { name: 'plan_step_done' },
+    )
+
+    // plan_abandon — abandon current plan
+    api.registerTool(
+      {
+        name: 'plan_abandon',
+        label: 'Abandon Plan',
+        description:
+          'Abandon the current plan. The coordinator will stop sending plan nudges.',
+        parameters: Type.Object({}),
+        async execute(_toolCallId: string, _params: unknown) {
+          const b = await ensureBackend()
+          const result = b.abandonPlan()
+          if ('error' in result) {
+            return { content: [{ type: 'text', text: `Failed: ${result.error}` }] }
+          }
+          return {
+            content: [{ type: 'text', text: `Plan abandoned: ${result.plan.goal}` }],
+            details: result,
+          }
+        },
+      },
+      { name: 'plan_abandon' },
+    )
+
+    // plan_get — view current plan state
+    api.registerTool(
+      {
+        name: 'plan_get',
+        label: 'Get Plan',
+        description:
+          'View the current plan state including goal, steps, and progress.',
+        parameters: Type.Object({}),
+        async execute(_toolCallId: string, _params: unknown) {
+          const b = await ensureBackend()
+          const result = b.getPlan()
+          if (!result.plan) {
+            return { content: [{ type: 'text', text: 'No active plan.' }] }
+          }
+          const p = result.plan
+          const stepList = p.steps.map((s, i) => {
+            const marker = s.status === 'done' ? '[x]' : '[ ]'
+            return `  ${marker} ${i}. ${s.description}`
+          }).join('\n')
+          return {
+            content: [{ type: 'text', text: `Plan (${p.status}): ${p.goal}\n${stepList}` }],
+            details: result,
+          }
+        },
+      },
+      { name: 'plan_get' },
+    )
+
     // Service lifecycle
     api.registerService({
       id: 'crawd',

package/src/types.ts

@@ -13,41 +13,22 @@ export type {
   SuperChatInfo,
 } from './lib/chat/types'
 
-/** TTS provider identifier */
-export type TtsProvider = 'openai' | 'elevenlabs' | 'tiktok'
-
 // --- Socket.IO event payloads ---
 
-/** Turn-based reply: chat message + bot response, each with TTS audio */
+/** Turn-based reply: chat message + bot response (text only, TTS handled by overlay) */
 export type ReplyTurnEvent = {
-  /** Correlation ID — overlay sends talk:done with this ID when both audios finish */
+  /** Correlation ID — overlay sends talk:done with this ID when finished */
   id: string
   chat: { username: string; message: string }
   botMessage: string
-  chatTtsUrl: string
-  botTtsUrl: string
-  /** TTS provider used for the chat audio */
-  chatTtsProvider?: TtsProvider
-  /** TTS provider used for the bot audio */
-  botTtsProvider?: TtsProvider
 }
 
-/** Bot speech bubble with pre-generated TTS (atomic event) */
+/** Bot speech bubble (text only, TTS handled by overlay) */
 export type TalkEvent = {
-  /** Correlation ID — overlay sends talk:done with this ID when audio finishes */
+  /** Correlation ID — overlay sends talk:done with this ID when finished */
   id: string
   /** Bot reply text */
   message: string
-  /** Bot TTS audio URL */
-  ttsUrl: string
-  /** TTS provider used for the bot audio */
-  ttsProvider?: TtsProvider
-  /** Optional: chat message being replied to (overlay plays this first) */
-  chat?: {
-    message: string
-    username: string
-    ttsUrl: string
-  }
 }
 
 /** Overlay → backend acknowledgement that a talk finished playing */