@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/tools/background-task/task-result-format.ts

@@ -1,113 +0,0 @@
-import type { BackgroundTask } from "../../features/background-agent"
-import { consumeNewMessages } from "../../shared/session-cursor"
-import type { BackgroundOutputClient, BackgroundOutputMessagesResult } from "./clients"
-import { extractMessages, getErrorMessage } from "./session-messages"
-import { formatDuration } from "./time-format"
-
-function getTimeString(value: unknown): string {
-  return typeof value === "string" ? value : ""
-}
-
-export async function formatTaskResult(task: BackgroundTask, client: BackgroundOutputClient): Promise<string> {
-  if (!task.sessionID) {
-    return `Error: Task has no sessionID`
-  }
-
-  const messagesResult: BackgroundOutputMessagesResult = await client.session.messages({
-    path: { id: task.sessionID },
-  })
-
-  const errorMessage = getErrorMessage(messagesResult)
-  if (errorMessage) {
-    return `Error fetching messages: ${errorMessage}`
-  }
-
-  const messages = extractMessages(messagesResult)
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return `Task Result
-
-Task ID: ${task.id}
-Description: ${task.description}
-Duration: ${formatDuration(task.startedAt ?? new Date(), task.completedAt)}
-Session ID: ${task.sessionID}
-
----
-
-(No messages found)`
-  }
-
-  const relevantMessages = messages.filter((m) => m.info?.role === "assistant" || m.info?.role === "tool")
-  if (relevantMessages.length === 0) {
-    return `Task Result
-
-Task ID: ${task.id}
-Description: ${task.description}
-Duration: ${formatDuration(task.startedAt ?? new Date(), task.completedAt)}
-Session ID: ${task.sessionID}
-
----
-
-(No assistant or tool response found)`
-  }
-
-  const sortedMessages = [...relevantMessages].sort((a, b) => {
-    const timeA = getTimeString(a.info?.time)
-    const timeB = getTimeString(b.info?.time)
-    return timeA.localeCompare(timeB)
-  })
-
-  const newMessages = consumeNewMessages(task.sessionID, sortedMessages)
-  if (newMessages.length === 0) {
-    const duration = formatDuration(task.startedAt ?? new Date(), task.completedAt)
-    return `Task Result
-
-Task ID: ${task.id}
-Description: ${task.description}
-Duration: ${duration}
-Session ID: ${task.sessionID}
-
----
-
-(No new output since last check)`
-  }
-
-  const extractedContent: string[] = []
-  for (const message of newMessages) {
-    for (const part of message.parts ?? []) {
-      if ((part.type === "text" || part.type === "reasoning") && part.text) {
-        extractedContent.push(part.text)
-        continue
-      }
-
-      if (part.type === "tool_result") {
-        const toolResult = part as { content?: string | Array<{ type: string; text?: string }> }
-        if (typeof toolResult.content === "string" && toolResult.content) {
-          extractedContent.push(toolResult.content)
-          continue
-        }
-
-        if (Array.isArray(toolResult.content)) {
-          for (const block of toolResult.content) {
-            if ((block.type === "text" || block.type === "reasoning") && block.text) {
-              extractedContent.push(block.text)
-            }
-          }
-        }
-      }
-    }
-  }
-
-  const textContent = extractedContent.filter((text) => text.length > 0).join("\n\n")
-  const duration = formatDuration(task.startedAt ?? new Date(), task.completedAt)
-
-  return `Task Result
-
-Task ID: ${task.id}
-Description: ${task.description}
-Duration: ${duration}
-Session ID: ${task.sessionID}
-
----
-
-${textContent || "(No text output)"}`
-}

package/src/tools/background-task/task-status-format.ts

@@ -1,72 +0,0 @@
-import type { BackgroundTask } from "../../features/background-agent"
-import { formatDuration } from "./time-format"
-import { truncateText } from "./truncate-text"
-
-export function formatTaskStatus(task: BackgroundTask): string {
-  let duration: string
-  if (task.status === "pending" && task.queuedAt) {
-    duration = formatDuration(task.queuedAt, undefined)
-  } else if (task.startedAt) {
-    duration = formatDuration(task.startedAt, task.completedAt)
-  } else {
-    duration = "N/A"
-  }
-
-  const promptPreview = truncateText(task.prompt, 500)
-
-  let progressSection = ""
-  if (task.progress?.lastTool) {
-    progressSection = `\n| Last tool | ${task.progress.lastTool} |`
-  }
-
-  let lastMessageSection = ""
-  if (task.progress?.lastMessage) {
-    const truncated = truncateText(task.progress.lastMessage, 500)
-    const messageTime = task.progress.lastMessageAt ? task.progress.lastMessageAt.toISOString() : "N/A"
-    lastMessageSection = `
-
-## Last Message (${messageTime})
-
-\`\`\`
-${truncated}
-\`\`\``
-  }
-
-   let statusNote = ""
-   if (task.status === "pending") {
-     statusNote = `
-
-> **Queued**: Task is waiting for a concurrency slot to become available.`
-   } else if (task.status === "running") {
-     statusNote = `
-
-> **Note**: No need to wait explicitly - the system will notify you when this task completes.`
-   } else if (task.status === "error") {
-     statusNote = `
-
-> **Failed**: The task encountered an error. Check the last message for details.`
-   } else if (task.status === "interrupt") {
-     statusNote = `
-
-> **Interrupted**: The task was interrupted by a prompt error. The session may contain partial results.`
-   }
-
-  const durationLabel = task.status === "pending" ? "Queued for" : "Duration"
-
-  return `# Task Status
-
-| Field | Value |
-|-------|-------|
-| Task ID | \`${task.id}\` |
-| Description | ${task.description} |
-| Agent | ${task.agent} |
-| Status | **${task.status}** |
-| ${durationLabel} | ${duration} |
-| Session ID | \`${task.sessionID}\` |${progressSection}
-${statusNote}
-## Original Prompt
-
-\`\`\`
-${promptPreview}
-\`\`\`${lastMessageSection}`
-}

package/src/tools/background-task/time-format.ts

@@ -1,30 +0,0 @@
-export function formatDuration(start: Date, end?: Date): string {
-  const duration = (end ?? new Date()).getTime() - start.getTime()
-  const seconds = Math.floor(duration / 1000)
-  const minutes = Math.floor(seconds / 60)
-  const hours = Math.floor(minutes / 60)
-
-  if (hours > 0) {
-    return `${hours}h ${minutes % 60}m ${seconds % 60}s`
-  }
-  if (minutes > 0) {
-    return `${minutes}m ${seconds % 60}s`
-  }
-  return `${seconds}s`
-}
-
-export function formatMessageTime(value: unknown): string {
-  if (typeof value === "string") {
-    const date = new Date(value)
-    return Number.isNaN(date.getTime()) ? value : date.toISOString()
-  }
-  if (typeof value === "object" && value !== null) {
-    if ("created" in value) {
-      const created = (value as { created?: number }).created
-      if (typeof created === "number") {
-        return new Date(created).toISOString()
-      }
-    }
-  }
-  return "Unknown time"
-}

package/src/tools/background-task/tools.ts

@@ -1,11 +0,0 @@
-export type {
-  BackgroundCancelClient,
-  BackgroundOutputClient,
-  BackgroundOutputManager,
-  BackgroundOutputMessage,
-  BackgroundOutputMessagesResult,
-} from "./clients"
-
-export { createBackgroundTask } from "./create-background-task"
-export { createBackgroundOutput } from "./create-background-output"
-export { createBackgroundCancel } from "./create-background-cancel"

package/src/tools/background-task/truncate-text.ts

@@ -1,4 +0,0 @@
-export function truncateText(text: string, maxLength: number): string {
-  if (text.length <= maxLength) return text
-  return text.slice(0, maxLength) + "..."
-}

package/src/tools/background-task/types.ts

@@ -1,72 +0,0 @@
-export interface BackgroundTaskArgs {
-  description: string
-  prompt: string
-  agent: string
-}
-
-export interface BackgroundOutputArgs {
-  task_id: string
-  block?: boolean
-  timeout?: number
-  full_session?: boolean
-  include_thinking?: boolean
-  message_limit?: number
-  since_message_id?: string
-  include_tool_results?: boolean
-  thinking_max_chars?: number
-}
-
-export interface BackgroundCancelArgs {
-  taskId?: string
-  all?: boolean
-}
-
-export type BackgroundOutputMessage = {
-  info?: { role?: string; time?: string | { created?: number }; agent?: string }
-  parts?: Array<{
-    type?: string
-    text?: string
-    content?: string | Array<{ type: string; text?: string }>
-    name?: string
-  }>
-}
-
-export type BackgroundOutputMessagesResult =
-  | { data?: BackgroundOutputMessage[]; error?: unknown }
-  | BackgroundOutputMessage[]
-
-export type BackgroundOutputClient = {
-  session: {
-    messages: (args: { path: { id: string } }) => Promise<BackgroundOutputMessagesResult>
-  }
-}
-
-export type BackgroundCancelClient = {
-  session: {
-    abort: (args: { path: { id: string } }) => Promise<unknown>
-  }
-}
-
-export type BackgroundOutputManager = Pick<import("../../features/background-agent").BackgroundManager, "getTask">
-
-export type FullSessionMessagePart = {
-  type?: string
-  text?: string
-  thinking?: string
-  content?: string | Array<{ type?: string; text?: string }>
-  output?: string
-}
-
-export type FullSessionMessage = {
-  id?: string
-  info?: { role?: string; time?: string; agent?: string }
-  parts?: FullSessionMessagePart[]
-}
-
-export type ToolContextWithMetadata = {
-  sessionID: string
-  messageID: string
-  agent: string
-  abort: AbortSignal
-  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
-}

package/src/tools/call-omo-agent/AGENTS.md

@@ -1,51 +0,0 @@
-# src/tools/call-omo-agent/ — Direct Agent Invocation Tool
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-23 files. The `call_omo_agent` tool — direct invocation of canonical specialist agents (`researcher`, `strategist`, `coder`, `critic`, `designer`, `brainstormer`, `platform-manager`, `multimodal`) plus compatibility aliases and custom agents. Distinct from `delegate-task`: no category system, no skill loading, no model selection. Fixed agent set, same execution modes (background/sync).
-
-## DISTINCTION FROM delegate-task
-
-| Aspect | `call_omo_agent` | `delegate-task` (`task`) |
-|--------|-----------------|--------------------------|
-| Agent selection | Canonical agent (preferred) or compatibility alias | Category or subagent_type |
-| Skill loading | None | `load_skills[]` supported |
-| Model selection | From agent's fallback chain | From category config |
-| Use case | Quick contextual grep | Full delegation with skills |
-
-## ALLOWED AGENTS
-
-Canonical built-ins are preferred; compatibility aliases remain accepted via `ALLOWED_AGENTS` in `constants.ts`. Case-insensitive validation.
-
-## EXECUTION MODES
-
-Same two modes as delegate-task:
-
-| Mode | File | Description |
-|------|------|-------------|
-| **Background** | `background-agent-executor.ts` | Async via `BackgroundManager` |
-| **Sync** | `sync-executor.ts` | Create session → wait for idle → return result |
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `tools.ts` | `createCallOmoAgent()` factory — validates agent, routes to executor |
-| `background-executor.ts` | Routes to background or sync based on `run_in_background` |
-| `background-agent-executor.ts` | Launch via `BackgroundManager.launch()` |
-| `sync-executor.ts` | Synchronous session: create → send prompt → poll → fetch result |
-| `session-creator.ts` | Create OpenCode session for sync execution |
-| `subagent-session-creator.ts` | Create session with agent-specific config |
-| `subagent-session-prompter.ts` | Inject prompt into session |
-| `completion-poller.ts` | Poll until session idle |
-| `session-completion-poller.ts` | Session-specific completion check |
-| `session-message-output-extractor.ts` | Extract last assistant message as result |
-| `message-processor.ts` | Process raw message content |
-| `message-dir.ts` + `message-storage-directory.ts` | Temp storage for message exchange |
-| `types.ts` | `CallOmoAgentArgs`, `AllowedAgentType`, `ToolContextWithMetadata` |
-
-## SESSION CONTINUATION
-
-Pass `session_id` to resume an existing session rather than create a new one — handled in both executors.

package/src/tools/call-omo-agent/agent-resolver.ts

@@ -1,64 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { ALLOWED_AGENTS } from "./constants";
-import { normalizeSDKResponse } from "../../shared";
-import { log } from "../../shared/logger";
-
-type AgentInfo = {
-  name: string;
-  mode?: "subagent" | "primary" | "all";
-};
-
-const callableAgentsCache = new Map<string, { agents: string[]; timestamp: number }>();
-const CACHE_TTL_MS = 30_000;
-
-export function clearCallableAgentsCache(): void {
-  callableAgentsCache.clear();
-}
-
-/**
- * Resolves the set of callable agent names at execute-time by merging the
- * hardcoded `ALLOWED_AGENTS` with any additional agents discovered dynamically
- * via `client.app.agents()`. Custom agents loaded from registered agent
- * directories appear here alongside built-ins.
- *
- * Results are cached per session for 30s to avoid redundant SDK IPC calls.
- *
- * Falls back to `ALLOWED_AGENTS` alone if the dynamic lookup fails.
- *
- * @param client - The plugin client with access to the agent registry
- * @param sessionId - Optional session ID for cache scoping
- * @returns Array of lowercase callable agent names (excludes primary-mode agents)
- */
-export async function resolveCallableAgents(
-  client: PluginInput["client"],
-  sessionId?: string,
-): Promise<string[]> {
-  const cacheKey = sessionId ?? "__default__";
-  const cached = callableAgentsCache.get(cacheKey);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-    return cached.agents;
-  }
-
-  try {
-    const agentsResult = await client.app.agents();
-    const agents = normalizeSDKResponse(agentsResult, [] as AgentInfo[], {
-      preferResponseOnMissingData: true,
-    });
-
-    const dynamicAgents = agents
-      .filter((a) => a && typeof a.name === "string" && a.name.trim().length > 0 && a.mode !== "primary")
-      .map((a) => a.name.trim().toLowerCase());
-
-    const merged = new Set([...ALLOWED_AGENTS, ...dynamicAgents]);
-    const result = [...merged];
-    callableAgentsCache.set(cacheKey, { agents: result, timestamp: Date.now() });
-    return result;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    log(
-      "[call_omo_agent] Failed to resolve dynamic agents, falling back to built-in list",
-      { error: message },
-    );
-    return [...ALLOWED_AGENTS];
-  }
-}

package/src/tools/call-omo-agent/background-agent-executor.ts

@@ -1,91 +0,0 @@
-import type { BackgroundManager } from "../../features/background-agent"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { resolveMessageContext } from "../../features/hook-message-injector"
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import { log } from "../../shared"
-import type { CallOmoAgentArgs } from "./types"
-import type { ToolContextWithMetadata } from "./tool-context-with-metadata"
-import { getMessageDir } from "./message-storage-directory"
-import { getSessionTools } from "../../shared/session-tools-store"
-
-export async function executeBackgroundAgent(
-	args: CallOmoAgentArgs,
-	toolContext: ToolContextWithMetadata,
-	manager: BackgroundManager,
-	client: PluginInput["client"],
-): Promise<string> {
-	try {
-		const messageDir = getMessageDir(toolContext.sessionID)
-		const { prevMessage, firstMessageAgent } = await resolveMessageContext(
-			toolContext.sessionID,
-			client,
-			messageDir
-		)
-
-		const sessionAgent = getSessionAgent(toolContext.sessionID)
-		const parentAgent =
-			toolContext.agent ?? sessionAgent ?? firstMessageAgent ?? prevMessage?.agent
-
-		log("[call_omo_agent] parentAgent resolution", {
-			sessionID: toolContext.sessionID,
-			messageDir,
-			ctxAgent: toolContext.agent,
-			sessionAgent,
-			firstMessageAgent,
-			prevMessageAgent: prevMessage?.agent,
-			resolvedParentAgent: parentAgent,
-		})
-
-		const task = await manager.launch({
-			description: args.description,
-			prompt: args.prompt,
-			agent: args.subagent_type,
-			parentSessionID: toolContext.sessionID,
-			parentMessageID: toolContext.messageID,
-			parentAgent,
-			parentTools: getSessionTools(toolContext.sessionID),
-		})
-
-		const waitStart = Date.now()
-		const waitTimeoutMs = 30_000
-		const waitIntervalMs = 50
-
-		let sessionId = task.sessionID
-		while (!sessionId && Date.now() - waitStart < waitTimeoutMs) {
-			const updated = manager.getTask(task.id)
-			if (updated?.status === "error" || updated?.status === "cancelled" || updated?.status === "interrupt") {
-				return `Task failed to start (status: ${updated.status}).\n\nTask ID: ${task.id}`
-			}
-			sessionId = updated?.sessionID
-			if (sessionId) {
-				break
-			}
-			if (toolContext.abort?.aborted) {
-				break
-			}
-			await new Promise<void>((resolve) => {
-				setTimeout(resolve, waitIntervalMs)
-			})
-		}
-
-		await toolContext.metadata?.({
-			title: args.description,
-			metadata: { sessionId: sessionId ?? "pending" },
-		})
-
-		return `Background agent task launched successfully.
-
-Task ID: ${task.id}
-Session ID: ${sessionId ?? "pending"}
-Description: ${task.description}
-Agent: ${task.agent} (subagent)
-Status: ${task.status}
-
-System notifies on completion. Use \`background_output\` with task_id="${task.id}" to check.
-
-Do NOT call background_output now. Wait for <system-reminder> notification first.`
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error)
-		return `Failed to launch background agent task: ${message}`
-	}
-}

package/src/tools/call-omo-agent/background-executor.ts

@@ -1,98 +0,0 @@
-import type { CallOmoAgentArgs } from "./types"
-import type { BackgroundManager } from "../../features/background-agent"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared"
-import type { DelegatedModelConfig } from "../../shared/model-resolution-types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { resolveMessageContext } from "../../features/hook-message-injector"
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import { getMessageDir } from "./message-dir"
-import { getSessionTools } from "../../shared/session-tools-store"
-
-export async function executeBackground(
-  args: CallOmoAgentArgs,
-  toolContext: {
-    sessionID: string
-    messageID: string
-    agent: string
-    abort: AbortSignal
-    metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
-  },
-  manager: BackgroundManager,
-  client: PluginInput["client"],
-  fallbackChain?: FallbackEntry[],
-  model?: DelegatedModelConfig,
-): Promise<string> {
-  try {
-    const messageDir = getMessageDir(toolContext.sessionID)
-    const { prevMessage, firstMessageAgent } = await resolveMessageContext(
-      toolContext.sessionID,
-      client,
-      messageDir
-    )
-
-    const sessionAgent = getSessionAgent(toolContext.sessionID)
-    const parentAgent = toolContext.agent ?? sessionAgent ?? firstMessageAgent ?? prevMessage?.agent
-    
-    log("[call_omo_agent] parentAgent resolution", {
-      sessionID: toolContext.sessionID,
-      messageDir,
-      ctxAgent: toolContext.agent,
-      sessionAgent,
-      firstMessageAgent,
-      prevMessageAgent: prevMessage?.agent,
-      resolvedParentAgent: parentAgent,
-    })
-
-    const task = await manager.launch({
-      description: args.description,
-      prompt: args.prompt,
-      agent: args.subagent_type,
-      parentSessionID: toolContext.sessionID,
-      parentMessageID: toolContext.messageID,
-      parentAgent,
-      parentTools: getSessionTools(toolContext.sessionID),
-      model,
-      fallbackChain,
-    })
-
-    const WAIT_FOR_SESSION_INTERVAL_MS = 50
-    const WAIT_FOR_SESSION_TIMEOUT_MS = 30000
-    const waitStart = Date.now()
-    let sessionId = task.sessionID
-    while (!sessionId && Date.now() - waitStart < WAIT_FOR_SESSION_TIMEOUT_MS) {
-      const updated = manager.getTask(task.id)
-      if (updated?.status === "error" || updated?.status === "cancelled" || updated?.status === "interrupt") {
-        return `Task failed to start (status: ${updated.status}).\n\nTask ID: ${task.id}`
-      }
-      sessionId = updated?.sessionID
-      if (sessionId) {
-        break
-      }
-      if (toolContext.abort?.aborted) {
-        break
-      }
-      await new Promise(resolve => setTimeout(resolve, WAIT_FOR_SESSION_INTERVAL_MS))
-    }
-
-    await toolContext.metadata?.({
-      title: args.description,
-      metadata: { sessionId: sessionId ?? "pending" },
-    })
-
-    return `Background agent task launched successfully.
-
-Task ID: ${task.id}
-Session ID: ${sessionId ?? "pending"}
-Description: ${task.description}
-Agent: ${task.agent} (subagent)
-Status: ${task.status}
-
-System notifies on completion. Use \`background_output\` with task_id="${task.id}" to check.
-
-Do NOT call background_output now. Wait for <system-reminder> notification first.`
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    return `Failed to launch background agent task: ${message}`
-  }
-}

package/src/tools/call-omo-agent/completion-poller.ts

@@ -1,65 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared"
-import { normalizeSDKResponse } from "../../shared"
-
-export async function waitForCompletion(
-  sessionID: string,
-  toolContext: {
-    sessionID: string
-    messageID: string
-    agent: string
-    abort: AbortSignal
-    metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
-  },
-  ctx: PluginInput
-): Promise<void> {
-  log(`[call_omo_agent] Polling for completion...`)
-
-  const POLL_INTERVAL_MS = 500
-  const MAX_POLL_TIME_MS = 5 * 60 * 1000 // 5 minutes max
-  const pollStart = Date.now()
-  let lastMsgCount = 0
-  let stablePolls = 0
-  const STABILITY_REQUIRED = 3
-
-  while (Date.now() - pollStart < MAX_POLL_TIME_MS) {
-    if (toolContext.abort?.aborted) {
-      log(`[call_omo_agent] Aborted by user`)
-      throw new Error("Task aborted.")
-    }
-
-    await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS))
-
-    const statusResult = await ctx.client.session.status()
-    const allStatuses = normalizeSDKResponse(statusResult, {} as Record<string, { type: string }>)
-    const sessionStatus = allStatuses[sessionID]
-
-    if (sessionStatus && sessionStatus.type !== "idle") {
-      stablePolls = 0
-      lastMsgCount = 0
-      continue
-    }
-
-    const messagesCheck = await ctx.client.session.messages({ path: { id: sessionID } })
-    const msgs = normalizeSDKResponse(messagesCheck, [] as Array<unknown>, {
-      preferResponseOnMissingData: true,
-    })
-    const currentMsgCount = msgs.length
-
-    if (currentMsgCount > 0 && currentMsgCount === lastMsgCount) {
-      stablePolls++
-      if (stablePolls >= STABILITY_REQUIRED) {
-        log(`[call_omo_agent] Session complete, ${currentMsgCount} messages`)
-        break
-      }
-    } else {
-      stablePolls = 0
-      lastMsgCount = currentMsgCount
-    }
-  }
-
-  if (Date.now() - pollStart >= MAX_POLL_TIME_MS) {
-    log(`[call_omo_agent] Timeout reached`)
-    throw new Error("Agent task timed out after 5 minutes.")
-  }
-}