@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/background-task/full-session-format.ts

@@ -1,148 +0,0 @@
-import type { BackgroundTask } from "../../features/background-agent"
-import type { BackgroundOutputClient, BackgroundOutputMessagesResult, BackgroundOutputMessage } from "./clients"
-import { extractMessages, getErrorMessage } from "./session-messages"
-import { formatMessageTime } from "./time-format"
-import { truncateText } from "./truncate-text"
-import { formatTaskStatus } from "./task-status-format"
-
-const MAX_MESSAGE_LIMIT = 100
-const THINKING_MAX_CHARS = 2000
-
-function extractToolResultText(part: NonNullable<BackgroundOutputMessage["parts"]>[number]): string[] {
-  if (typeof part.content === "string" && part.content.length > 0) {
-    return [part.content]
-  }
-
-  if (Array.isArray(part.content)) {
-    const blocks: string[] = []
-    for (const block of part.content) {
-      if ((block.type === "text" || block.type === "reasoning") && block.text) {
-        blocks.push(block.text)
-      }
-    }
-    if (blocks.length > 0) return blocks
-  }
-
-  if (part.output && part.output.length > 0) {
-    return [part.output]
-  }
-
-  return []
-}
-
-export async function formatFullSession(
-  task: BackgroundTask,
-  client: BackgroundOutputClient,
-  options: {
-    includeThinking: boolean
-    messageLimit?: number
-    sinceMessageId?: string
-    includeToolResults: boolean
-    thinkingMaxChars?: number
-  }
-): Promise<string> {
-  if (!task.sessionID) {
-    return formatTaskStatus(task)
-  }
-
-  const messagesResult: BackgroundOutputMessagesResult = await client.session.messages({
-    path: { id: task.sessionID },
-  })
-
-  const errorMessage = getErrorMessage(messagesResult)
-  if (errorMessage) {
-    return `Error fetching messages: ${errorMessage}`
-  }
-
-  const rawMessages = extractMessages(messagesResult)
-  if (!Array.isArray(rawMessages)) {
-    return "Error fetching messages: invalid response"
-  }
-
-  const sortedMessages = [...rawMessages].sort((a, b) => {
-    const timeA = String(a.info?.time ?? "")
-    const timeB = String(b.info?.time ?? "")
-    return timeA.localeCompare(timeB)
-  })
-
-  let filteredMessages = sortedMessages
-  if (options.sinceMessageId) {
-    const index = filteredMessages.findIndex((message) => message.id === options.sinceMessageId)
-    if (index === -1) {
-      return `Error: since_message_id not found: ${options.sinceMessageId}`
-    }
-    filteredMessages = filteredMessages.slice(index + 1)
-  }
-
-  const includeThinking = options.includeThinking
-  const includeToolResults = options.includeToolResults
-  const thinkingMaxChars = options.thinkingMaxChars ?? THINKING_MAX_CHARS
-
-  const normalizedMessages: BackgroundOutputMessage[] = []
-  for (const message of filteredMessages) {
-    const parts = (message.parts ?? []).filter((part) => {
-      if (part.type === "thinking" || part.type === "reasoning") {
-        return includeThinking
-      }
-      if (part.type === "tool_result") {
-        return includeToolResults
-      }
-      return part.type === "text"
-    })
-
-    if (parts.length === 0) {
-      continue
-    }
-
-    normalizedMessages.push({ ...message, parts })
-  }
-
-  const limit = typeof options.messageLimit === "number" ? Math.min(options.messageLimit, MAX_MESSAGE_LIMIT) : undefined
-  const hasMore = limit !== undefined && normalizedMessages.length > limit
-  const visibleMessages = limit !== undefined ? normalizedMessages.slice(0, limit) : normalizedMessages
-
-  const lines: string[] = []
-  lines.push("# Full Session Output")
-  lines.push("")
-  lines.push(`Task ID: ${task.id}`)
-  lines.push(`Description: ${task.description}`)
-  lines.push(`Status: ${task.status}`)
-  lines.push(`Session ID: ${task.sessionID}`)
-  lines.push(`Total messages: ${normalizedMessages.length}`)
-  lines.push(`Returned: ${visibleMessages.length}`)
-  lines.push(`Has more: ${hasMore ? "true" : "false"}`)
-  lines.push("")
-  lines.push("## Messages")
-
-  if (visibleMessages.length === 0) {
-    lines.push("")
-    lines.push("(No messages found)")
-    return lines.join("\n")
-  }
-
-  for (const message of visibleMessages) {
-    const role = message.info?.role ?? "unknown"
-    const agent = message.info?.agent ? ` (${message.info.agent})` : ""
-    const time = formatMessageTime(message.info?.time)
-    const idLabel = message.id ? ` id=${message.id}` : ""
-    lines.push("")
-    lines.push(`[${role}${agent}] ${time}${idLabel}`)
-
-    for (const part of message.parts ?? []) {
-      if (part.type === "text" && part.text) {
-        lines.push(part.text.trim())
-      } else if (part.type === "thinking" && part.thinking) {
-        lines.push(`[thinking] ${truncateText(part.thinking, thinkingMaxChars)}`)
-      } else if (part.type === "reasoning" && part.text) {
-        lines.push(`[thinking] ${truncateText(part.text, thinkingMaxChars)}`)
-      } else if (part.type === "tool_result") {
-        const toolTexts = extractToolResultText(part)
-        for (const toolText of toolTexts) {
-          lines.push(`[tool result] ${toolText}`)
-        }
-      }
-    }
-  }
-
-  return lines.join("\n")
-}

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

@@ -1,8 +0,0 @@
-export {
-  createBackgroundTask,
-  createBackgroundOutput,
-  createBackgroundCancel,
-} from "./tools"
-
-export type * from "./types"
-export * from "./constants"

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

@@ -1 +0,0 @@
-export { getMessageDir } from "../../shared/opencode-message-dir"

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

@@ -1,22 +0,0 @@
-import type { BackgroundOutputMessage, BackgroundOutputMessagesResult } from "./clients"
-
-export function getErrorMessage(value: BackgroundOutputMessagesResult): string | null {
-  if (Array.isArray(value)) return null
-  if (value.error === undefined || value.error === null) return null
-  if (typeof value.error === "string" && value.error.length > 0) return value.error
-  return String(value.error)
-}
-
-function isSessionMessage(value: unknown): value is BackgroundOutputMessage {
-  return typeof value === "object" && value !== null
-}
-
-export function extractMessages(value: BackgroundOutputMessagesResult): BackgroundOutputMessage[] {
-  if (Array.isArray(value)) {
-    return value.filter(isSessionMessage)
-  }
-  if (Array.isArray(value.data)) {
-    return value.data.filter(isSessionMessage)
-  }
-  return []
-}

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];
-  }
-}