nikcli 0.0.6

package/src/tool/speak.ts

@@ -0,0 +1,440 @@
+import z from "zod"
+import path from "path"
+import os from "os"
+import { spawn } from "child_process"
+import { unlinkSync } from "fs"
+
+import { Tool } from "./tool"
+import { Log } from "@/util/log"
+import { Config } from "@/config/config"
+import { ttsRegistry, type TTSProvider } from "./speak/provider"
+import { ELEVENLABS_VOICES_LIST, elevenLabsProvider } from "./speak/elevenlabs"
+import { OPENROUTER_VOICES_LIST, openRouterProvider } from "./speak/openrouter"
+
+const log = Log.create({ service: "tool.speak" })
+
+const DEFAULT_VOICE_ID = "YOq2y2Up4RgXP2HyXjE5"
+const DEFAULT_MODEL_ID = "eleven_v3"
+const DEFAULT_OUTPUT_FORMAT = "mp3_44100_128"
+const OPENROUTER_DEFAULT_VOICE_ID = "alloy"
+const OPENROUTER_DEFAULT_MODEL_ID = "openai/gpt-audio-mini"
+const OPENROUTER_DEFAULT_OUTPUT_FORMAT = "mp3"
+const DEFAULT_PROVIDER = "openrouter"
+
+// Register built-in providers
+ttsRegistry.register(elevenLabsProvider)
+ttsRegistry.register(openRouterProvider)
+
+function defaultVoiceIdForProvider(providerId: string): string {
+  if (providerId === "openrouter") return OPENROUTER_DEFAULT_VOICE_ID
+  return DEFAULT_VOICE_ID
+}
+
+function defaultModelIdForProvider(providerId: string): string {
+  if (providerId === "openrouter") return OPENROUTER_DEFAULT_MODEL_ID
+  return DEFAULT_MODEL_ID
+}
+
+function defaultOutputFormatForProvider(providerId: string): string {
+  if (providerId === "openrouter") return OPENROUTER_DEFAULT_OUTPUT_FORMAT
+  return DEFAULT_OUTPUT_FORMAT
+}
+
+function envVoiceIdForProvider(providerId: string): string | undefined {
+  if (providerId === "openrouter") {
+    return process.env.NIKCLI_OPENROUTER_VOICE_ID
+  }
+  return process.env.NIKCLI_ELEVENLABS_VOICE_ID
+}
+
+function envModelIdForProvider(providerId: string): string | undefined {
+  if (providerId === "openrouter") {
+    return process.env.NIKCLI_OPENROUTER_MODEL_ID
+  }
+  return process.env.NIKCLI_ELEVENLABS_MODEL_ID
+}
+
+function envOutputFormatForProvider(providerId: string): string | undefined {
+  if (providerId === "openrouter") {
+    return process.env.NIKCLI_OPENROUTER_OUTPUT_FORMAT
+  }
+  return process.env.NIKCLI_ELEVENLABS_OUTPUT_FORMAT
+}
+
+// Helper to resolve providers list to try, starting with the primary choice
+async function resolveProvidersToTry(
+  providerParam?: string,
+  configProvider?: string,
+): Promise<{ provider: TTSProvider; id: string }[]> {
+  const primaryId = providerParam ?? configProvider ?? process.env.NIKCLI_SPEAK_PROVIDER ?? DEFAULT_PROVIDER
+
+  const primary = ttsRegistry.get(primaryId)
+  if (!primary) {
+    const available = ttsRegistry
+      .list()
+      .map((p) => p.id)
+      .join(", ")
+    throw new Error(`Unknown TTS provider: ${primaryId}. Available providers: ${available}`)
+  }
+
+  // Determine fallback order: primary first, then others
+  const others = ttsRegistry.list().filter((p) => p.id !== primaryId)
+
+  return [{ provider: primary, id: primaryId }, ...others.map((p) => ({ provider: p, id: p.id }))]
+}
+
+// Voice validation - currently only validates ElevenLabs voices
+const KNOWN_ELEVENLABS_VOICES = ELEVENLABS_VOICES_LIST.map((voice) => voice.id)
+const KNOWN_OPENROUTER_VOICES = new Set(OPENROUTER_VOICES_LIST.map((voice) => voice.id.toLowerCase()))
+
+// ElevenLabs voice IDs are typically 21-character alphanumeric strings
+const VOICE_ID_PATTERN = /^[a-zA-Z0-9_-]{21}$/
+
+function validateVoiceId(voiceId: string, providerId: string): { valid: boolean; isKnown: boolean } {
+  if (providerId === "openrouter") {
+    const normalized = voiceId.toLowerCase()
+    const isKnown = KNOWN_OPENROUTER_VOICES.has(normalized)
+    return { valid: isKnown, isKnown }
+  }
+
+  // For now, only strictly validate ElevenLabs voices by pattern
+  if (providerId !== "elevenlabs") {
+    return { valid: true, isKnown: false }
+  }
+
+  const matchesPattern = VOICE_ID_PATTERN.test(voiceId)
+  const isKnown = KNOWN_ELEVENLABS_VOICES.includes(voiceId)
+  return { valid: matchesPattern, isKnown }
+}
+
+function resolveVoiceId(
+  inputVoiceId: string | undefined,
+  configVoiceId: string | undefined,
+  envVoiceId: string | undefined,
+  providerId: string,
+): string {
+  const providedVoiceId = inputVoiceId ?? configVoiceId ?? envVoiceId
+
+  if (!providedVoiceId) {
+    return defaultVoiceIdForProvider(providerId)
+  }
+
+  const validation = validateVoiceId(providedVoiceId, providerId)
+
+  if (!validation.valid) {
+    log.warn("invalid voiceId format - using default", {
+      provided: providedVoiceId,
+      expected: `pattern: ${VOICE_ID_PATTERN.source}`,
+    })
+    return defaultVoiceIdForProvider(providerId)
+  }
+
+  if (!validation.isKnown) {
+    log.warn("voiceId not in known voices list - allowing anyway", {
+      voiceId: providedVoiceId,
+      providerId,
+      hint: "voice may work but is not in the known voices list",
+    })
+  }
+
+  return providedVoiceId
+}
+
+const DEFAULT_TIMEOUT_MS = 30_000
+const MAX_TIMEOUT_MS = 120_000
+const MAX_TEXT_LENGTH = 800
+
+type AudioPlayer = {
+  name: "afplay" | "ffplay" | "mpg123"
+  command: string
+  args: (input: { filePath: string; volume: number }) => string[]
+}
+
+function clampNumber(value: number, min: number, max: number): number {
+  if (value < min) return min
+  if (value > max) return max
+  return value
+}
+
+function detectPlayer(): AudioPlayer | undefined {
+  const afplay = Bun.which("afplay")
+  if (process.platform === "darwin" && afplay) {
+    return {
+      name: "afplay",
+      command: afplay,
+      args: ({ filePath, volume }) => ["-v", String(clampNumber(volume, 0, 2)), filePath],
+    }
+  }
+
+  const ffplay = Bun.which("ffplay")
+  if (ffplay) {
+    // ffplay expects volume in 0-100.
+    return {
+      name: "ffplay",
+      command: ffplay,
+      args: ({ filePath, volume }) => {
+        const vol = Math.round(clampNumber(volume, 0, 1) * 100)
+        return ["-nodisp", "-autoexit", "-loglevel", "error", "-volume", String(vol), filePath]
+      },
+    }
+  }
+
+  const mpg123 = Bun.which("mpg123")
+  if (mpg123) {
+    return {
+      name: "mpg123",
+      command: mpg123,
+      args: ({ filePath }) => ["-q", filePath],
+    }
+  }
+
+  return undefined
+}
+
+function normalizeText(input: string): { text: string; truncated: boolean } {
+  const text = input.trim()
+  if (!text) throw new Error("Text is required")
+  if (text.length <= MAX_TEXT_LENGTH) return { text, truncated: false }
+  return { text: text.slice(0, MAX_TEXT_LENGTH - 3) + "...", truncated: true }
+}
+
+function extensionFromContentType(contentType: string) {
+  const lower = contentType.toLowerCase()
+  if (lower.includes("wav")) return "wav"
+  if (lower.includes("mp3")) return "mp3"
+  return "bin"
+}
+
+function playAudioNonBlocking(player: AudioPlayer, filePath: string, volume: number) {
+  const cleanup = () => {
+    try {
+      unlinkSync(filePath)
+    } catch {
+      // Ignore cleanup failures.
+    }
+  }
+
+  const child = spawn(player.command, player.args({ filePath, volume }), {
+    detached: process.platform !== "win32",
+    stdio: "ignore",
+  })
+
+  child.unref()
+  child.once("exit", cleanup)
+  child.once("error", (error) => {
+    log.error("audio playback failed", { error: error.message, player: player.name })
+    cleanup()
+  })
+}
+
+const DESCRIPTION = `Convert text to speech and play it on the machine speakers (non-blocking).
+
+This tool supports multiple TTS providers (ElevenLabs and OpenRouter).
+
+Audio tag examples (ElevenLabs):
+  [laughs] [sighs] [excited] [sad] [angry]
+  [whispers] [shouts] [dramatically] [calmly]
+  [British accent] [strong French accent]
+
+Usage guidance:
+- Use in short bursts to notify about important state changes
+- Good for: task completion, errors requiring attention, questions needing user input
+- Keep messages concise (1-2 sentences)
+
+Note: audio plays on the device running nikcli.`
+
+export const SpeakTool = Tool.define("speak", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    text: z.string().describe("Text to speak. Can include audio tags like [laughs], [whispers], [excited], etc."),
+    provider: z.string().optional().describe("TTS provider (e.g., elevenlabs, openrouter)"),
+    stability: z
+      .number()
+      .min(0)
+      .max(1)
+      .optional()
+      .describe("Voice stability (0-1). Lower = more expressive. Default: 0.5"),
+    similarityBoost: z.number().min(0).max(1).optional().describe("Voice similarity boost (0-1). Default: 0.75"),
+    speed: z.number().min(0.5).max(2).optional().describe("Speech speed multiplier (0.5-2). Default: 1.0"),
+    volume: z.number().min(0).max(2).optional().describe("Playback volume (0-2). Default: 1.0"),
+    voiceId: z.string().optional().describe("TTS voice ID (provider-dependent default)"),
+    modelId: z.string().optional().describe("TTS model ID (provider-dependent default)"),
+    outputFormat: z.string().optional().describe("TTS output format (provider-dependent default)"),
+    timeoutMs: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe(`Request timeout in milliseconds (default: ${DEFAULT_TIMEOUT_MS})`),
+  }),
+  async execute(params, ctx) {
+    const config = await Config.get()
+    const speakConfig = config.speak ?? {}
+
+    const player = detectPlayer()
+    if (!player) {
+      throw new Error(
+        [
+          "No supported audio player found.",
+          "",
+          "Supported players:",
+          "- macOS: afplay",
+          "- ffmpeg: ffplay",
+          "- mpg123: mpg123",
+        ].join("\n"),
+      )
+    }
+
+    // Resolve providers list
+    const providersToTry = await resolveProvidersToTry(params.provider, speakConfig.provider)
+    const failureLogs: string[] = []
+
+    for (const { provider: ttsProvider, id: providerId } of providersToTry) {
+      const voiceId = resolveVoiceId(params.voiceId, speakConfig.model, envVoiceIdForProvider(providerId), providerId)
+      const modelId =
+        params.modelId ??
+        speakConfig.modelId ??
+        envModelIdForProvider(providerId) ??
+        defaultModelIdForProvider(providerId)
+      const outputFormat =
+        params.outputFormat ??
+        speakConfig.outputFormat ??
+        envOutputFormatForProvider(providerId) ??
+        defaultOutputFormatForProvider(providerId)
+
+      const stability = params.stability ?? 0.5
+      const similarityBoost = params.similarityBoost ?? 0.75
+      const speed = params.speed ?? 1.0
+      const volume = params.volume ?? 1.0
+      const timeoutMs = clampNumber(params.timeoutMs ?? DEFAULT_TIMEOUT_MS, 1000, MAX_TIMEOUT_MS)
+
+      const normalized = normalizeText(params.text)
+
+      // Optionally check if provider is valid (auth keys present)
+      // This helps quickly skip providers that are unconfigured
+      const validation = await ttsProvider.validate().catch((e) => ({ valid: false, error: e.message }))
+      if (!validation.valid) {
+        log.warn(`Provider ${providerId} validation failed, skipping`, { error: validation.error })
+        failureLogs.push(`[${providerId}] Skipped: Configuration invalid or missing API key (${validation.error})`)
+        continue
+      }
+
+      try {
+        await ctx.ask({
+          permission: "speak",
+          patterns: [`${providerId}:${voiceId}`],
+          always: [`${providerId}*`],
+          metadata: {
+            provider: providerId,
+            voiceId,
+            modelId,
+            outputFormat,
+            player: player.name,
+            timeoutMs,
+          },
+        })
+      } catch (askError: any) {
+        // If the user rejects the permission, we must throw immediately
+        throw askError
+      }
+
+      const controller = new AbortController()
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs)
+
+      try {
+        const ttsResponse = await ttsProvider
+          .speak(
+            {
+              text: normalized.text,
+              voiceId,
+              modelId,
+              outputFormat,
+              stability,
+              similarityBoost,
+              speed,
+            },
+            { signal: AbortSignal.any([controller.signal, ctx.abort]) },
+          )
+          .finally(() => clearTimeout(timeoutId))
+
+        const ext = extensionFromContentType(ttsResponse.contentType)
+        const tempFile = path.join(
+          os.tmpdir(),
+          `nikcli-speak-${Date.now()}-${Math.random().toString(16).slice(2)}.${ext}`,
+        )
+
+        await Bun.write(tempFile, ttsResponse.audio)
+        playAudioNonBlocking(player, tempFile, volume)
+
+        const preview = normalized.text.length > 80 ? normalized.text.slice(0, 80) + "..." : normalized.text
+        const truncated = normalized.truncated ? " (text truncated)" : ""
+
+        const outputText = [
+          `Playing speech (non-blocking): "${preview}"${truncated}`,
+          `Provider: ${ttsProvider.name} (${modelId})`,
+          `Voice: ${voiceId}`,
+          `Player: ${player.name}`,
+        ]
+
+        if (failureLogs.length > 0) {
+          outputText.push(`\nFallback sequence:`)
+          outputText.push(...failureLogs)
+          outputText.push(`[${providerId}] Success!`)
+        }
+
+        return {
+          title: "Speak",
+          output: outputText.join("\n"),
+          metadata: {
+            provider: providerId,
+            voiceId,
+            modelId,
+            outputFormat,
+            player: player.name,
+            textTruncated: normalized.truncated,
+            fallbacks: failureLogs.length,
+          },
+        }
+      } catch (fetchError: any) {
+        const errorMessage = fetchError.cause?.message ?? fetchError.message
+
+        if (fetchError.name === "AbortError") {
+          if (ctx.abort.aborted) {
+            log.warn("request cancelled by user", { timeoutMs })
+            throw new Error("Speech request was cancelled")
+          }
+          log.error("request timed out", { timeoutMs, voiceId, modelId, provider: providerId })
+          failureLogs.push(`[${providerId}] Failed: Request timed out after ${timeoutMs}ms`)
+          continue
+        }
+
+        log.error(`network error calling ${ttsProvider.name} API`, {
+          error: errorMessage,
+          voiceId,
+          modelId,
+          provider: providerId,
+        })
+
+        if (errorMessage.includes("ENOTFOUND") || errorMessage.includes("dns")) {
+          failureLogs.push(`[${providerId}] Failed: DNS/Network error. Check internet connection.`)
+        } else if (errorMessage.includes("ECONNREFUSED")) {
+          failureLogs.push(`[${providerId}] Failed: Connection refused. Service may be unavailable.`)
+        } else {
+          failureLogs.push(`[${providerId}] Failed: ${errorMessage}`)
+        }
+
+        // Loop continues to next provider
+      }
+    }
+
+    // If we reach here, all providers failed
+    if (failureLogs.length > 0) {
+      throw new Error(`All TTS providers failed to speak:\n${failureLogs.join("\n")}`)
+    } else {
+      throw new Error("No available TTS providers could be used.")
+    }
+  },
+})
+
+// Export the provider registry for external use (e.g., CLI commands)
+export { ttsRegistry }

package/src/tool/task.ts

@@ -0,0 +1,194 @@
+import { Tool } from "./tool"
+import DESCRIPTION from "./task.txt"
+import z from "zod"
+import { Session } from "../session"
+import { Bus } from "../bus"
+import { MessageV2 } from "../session/message-v2"
+import { Identifier } from "../id/id"
+import { Agent } from "../agent/agent"
+import { SessionPrompt } from "../session/prompt"
+import { iife } from "@/util/iife"
+import { defer } from "@/util/defer"
+import { Config } from "../config/config"
+import { PermissionNext } from "@/permission/next"
+
+const parameters = z.object({
+  description: z.string().describe("A short (3-5 words) description of the task"),
+  prompt: z.string().describe("The task for the agent to perform"),
+  subagent_type: z.string().describe("The type of specialized agent to use for this task"),
+  session_id: z.string().describe("Existing Task session to continue").optional(),
+  command: z.string().describe("The command that triggered this task").optional(),
+})
+
+export type TaskParams = z.infer<typeof parameters>
+
+export async function runSubtask(params: TaskParams, ctx: Tool.Context) {
+  const config = await Config.get()
+  const bypass = Boolean(ctx.extra?.bypassAgentCheck)
+
+  if (!bypass) {
+    await ctx.ask({
+      permission: "task",
+      patterns: [params.subagent_type],
+      always: ["*"],
+      metadata: {
+        description: params.description,
+        subagent_type: params.subagent_type,
+      },
+    })
+  }
+
+  const agent = await Agent.get(params.subagent_type)
+  if (!agent) throw new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`)
+
+  const hasTaskPermission = agent.permission.some((rule) => rule.permission === "task")
+
+  const session = await iife(async () => {
+    if (params.session_id) {
+      const found = await Session.get(params.session_id).catch(() => {})
+      if (found) return found
+    }
+
+    return await Session.create({
+      parentID: ctx.sessionID,
+      title: params.description + ` (@${agent.name} subagent)`,
+      permission: [
+        {
+          permission: "todowrite",
+          pattern: "*",
+          action: "deny",
+        },
+        {
+          permission: "todoread",
+          pattern: "*",
+          action: "deny",
+        },
+        ...(hasTaskPermission
+          ? []
+          : [
+              {
+                permission: "task" as const,
+                pattern: "*" as const,
+                action: "deny" as const,
+              },
+            ]),
+        ...(config.experimental?.primary_tools?.map((t) => ({
+          pattern: "*",
+          action: "allow" as const,
+          permission: t,
+        })) ?? []),
+      ],
+    })
+  })
+
+  const msg = await MessageV2.get({ sessionID: ctx.sessionID, messageID: ctx.messageID })
+  if (msg.info.role !== "assistant") throw new Error("Not an assistant message")
+
+  ctx.metadata({
+    title: params.description,
+    metadata: {
+      sessionId: session.id,
+    },
+  })
+
+  const messageID = Identifier.ascending("message")
+  const parts: Record<string, { id: string; tool: string; state: { status: string; title?: string } }> = {}
+  const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
+    if (evt.properties.part.sessionID !== session.id) return
+    if (evt.properties.part.messageID === messageID) return
+    if (evt.properties.part.type !== "tool") return
+    const part = evt.properties.part
+    parts[part.id] = {
+      id: part.id,
+      tool: part.tool,
+      state: {
+        status: part.state.status,
+        title: part.state.status === "completed" ? part.state.title : undefined,
+      },
+    }
+    ctx.metadata({
+      title: params.description,
+      metadata: {
+        summary: Object.values(parts).sort((a, b) => a.id.localeCompare(b.id)),
+        sessionId: session.id,
+      },
+    })
+  })
+
+  const model = agent.model ?? {
+    modelID: msg.info.modelID,
+    providerID: msg.info.providerID,
+  }
+
+  function cancel() {
+    SessionPrompt.cancel(session.id)
+  }
+  ctx.abort.addEventListener("abort", cancel)
+  using _ = defer(() => ctx.abort.removeEventListener("abort", cancel))
+  const promptParts = await SessionPrompt.resolvePromptParts(params.prompt)
+
+  const result = await SessionPrompt.prompt({
+    messageID,
+    sessionID: session.id,
+    model: {
+      modelID: model.modelID,
+      providerID: model.providerID,
+    },
+    agent: agent.name,
+    tools: {
+      todowrite: false,
+      todoread: false,
+      ...(hasTaskPermission ? {} : { task: false }),
+      ...Object.fromEntries((config.experimental?.primary_tools ?? []).map((t) => [t, false])),
+    },
+    parts: promptParts,
+  })
+  unsub()
+  const messages = await Session.messages({ sessionID: session.id })
+  const summary = messages
+    .filter((x) => x.info.role === "assistant")
+    .flatMap((msg) => msg.parts.filter((x: any) => x.type === "tool") as MessageV2.ToolPart[])
+    .map((part) => ({
+      id: part.id,
+      tool: part.tool,
+      state: {
+        status: part.state.status,
+        title: part.state.status === "completed" ? part.state.title : undefined,
+      },
+    }))
+  const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
+
+  const output = text + "\n\n" + ["<task_metadata>", `session_id: ${session.id}`, "</task_metadata>"].join("\n")
+
+  return {
+    title: params.description,
+    metadata: {
+      summary,
+      sessionId: session.id,
+    },
+    output,
+  }
+}
+
+export const TaskTool = Tool.define("task", async (ctx) => {
+  const agents = await Agent.list().then((x) => x.filter((a) => a.mode !== "primary"))
+
+  const caller = ctx?.agent
+  const accessibleAgents = caller
+    ? agents.filter((a) => PermissionNext.evaluate("task", a.name, caller.permission).action !== "deny")
+    : agents
+
+  const description = DESCRIPTION.replace(
+    "{agents}",
+    accessibleAgents
+      .map((a) => `- ${a.name}: ${a.description ?? "This subagent should only be called manually by the user."}`)
+      .join("\n"),
+  )
+  return {
+    description,
+    parameters,
+    async execute(params: z.infer<typeof parameters>, ctx) {
+      return runSubtask(params, ctx)
+    },
+  }
+})

package/src/tool/task.txt

@@ -0,0 +1,60 @@
+Launch a new agent to handle complex, multistep tasks autonomously.
+
+Available agent types and the tools they have access to:
+{agents}
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+When to use the Task tool:
+- When you are instructed to execute custom slash commands. Use the Task tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description="Check the file", prompt="/check-file path/to/file.py")
+
+When NOT to use the Task tool:
+- If you want to read a specific file path, use the Read or Glob tool instead of the Task tool, to find the match more quickly
+- If you are searching for a specific class definition like "class Foo", use the Glob tool instead, to find the match more quickly
+- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Task tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+
+
+Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless unless you provide a session_id. Your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+
+Example usage (NOTE: The agents below are fictional examples for illustration only - use the actual agents listed above):
+
+<example_agent_descriptions>
+"code-reviewer": use this agent after you are done writing a significant piece of code
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the Write tool to write a function that checks if a number is prime
+assistant: I'm going to use the Write tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
+  }
+  return true
+}
+</code>
+<commentary>
+Since a significant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
+</commentary>
+assistant: Now let me use the code-reviewer agent to review the code
+assistant: Uses the Task tool to launch the code-reviewer agent
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
+</example>