@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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

@@ -1,23 +0,0 @@
-export const PRIMARY_ALLOWED_AGENTS = [
-  "researcher",
-  "strategist",
-  "coder",
-  "critic",
-  "designer",
-  "brainstormer",
-  "platform-manager",
-  "multimodal",
-] as const
-
-export const ALLOWED_AGENTS = [
-  ...PRIMARY_ALLOWED_AGENTS,
-] as const
-
-export const CALL_OMO_AGENT_DESCRIPTION = `Spawn canonical agents or custom agents. run_in_background REQUIRED (true=async with task_id, false=sync).
-
-Canonical built-in agents:
-{primary_agents}
-
-Custom agents registered via user or project agent directories are also supported.
-
-Pass \`session_id=<id>\` to continue previous agent with full context. Nested subagent depth is tracked automatically and blocked past the configured limit. Prompts MUST be in English. Use \`background_output\` for async results.`

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

@@ -1,3 +0,0 @@
-export * from "./types"
-export * from "./constants"
-export { createCallOmoAgent } from "./tools"

package/src/tools/call-omo-agent/message-dir.ts

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

package/src/tools/call-omo-agent/message-processor.ts

@@ -1,86 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared"
-import { consumeNewMessages } from "../../shared/session-cursor"
-
-interface SDKMessage {
-  info?: { role?: string; time?: { created?: number } }
-  parts?: Array<{ type: string; text?: string; content?: string | Array<{ type: string; text?: string }> }>
-}
-
-export async function processMessages(
-  sessionID: string,
-  ctx: PluginInput
-): Promise<string> {
-  const messagesResult = await ctx.client.session.messages({
-    path: { id: sessionID },
-  })
-
-  if (messagesResult.error) {
-    log(`[call_omo_agent] Messages error:`, messagesResult.error)
-    throw new Error(`Failed to get messages: ${messagesResult.error}`)
-  }
-
-  const messages = messagesResult.data
-  log(`[call_omo_agent] Got ${messages.length} messages`)
-
-  // Include both assistant messages AND tool messages
-  // Tool results (grep, glob, bash output) come from role "tool"
-  const relevantMessages = messages.filter(
-    (m: SDKMessage) => m.info?.role === "assistant" || m.info?.role === "tool"
-  )
-
-  if (relevantMessages.length === 0) {
-    log(`[call_omo_agent] No assistant or tool messages found`)
-    log(`[call_omo_agent] All messages:`, JSON.stringify(messages, null, 2))
-    throw new Error("No assistant or tool response found")
-  }
-
-  log(`[call_omo_agent] Found ${relevantMessages.length} relevant messages`)
-
-  // Sort by time ascending (oldest first) to process messages in order
-  const sortedMessages = [...relevantMessages].sort((a: SDKMessage, b: SDKMessage) => {
-    const timeA = a.info?.time?.created ?? 0
-    const timeB = b.info?.time?.created ?? 0
-    return timeA - timeB
-  })
-
-  const newMessages = consumeNewMessages(sessionID, sortedMessages)
-
-  if (newMessages.length === 0) {
-    return "No new output since last check."
-  }
-
-  // Extract content from ALL messages, not just the last one
-  // Tool results may be in earlier messages while the final message is empty
-  const extractedContent: string[] = []
-
-  for (const message of newMessages) {
-    for (const part of message.parts ?? []) {
-      // Handle both "text" and "reasoning" parts (thinking models use "reasoning")
-      if ((part.type === "text" || part.type === "reasoning") && part.text) {
-        extractedContent.push(part.text)
-      } else if ((part.type as string) === "tool_result") {
-        // Tool results contain the actual output from tool calls
-        const toolResult = part as { content?: string | Array<{ type: string; text?: string }> }
-        if (typeof toolResult.content === "string" && toolResult.content) {
-          extractedContent.push(toolResult.content)
-        } else if (Array.isArray(toolResult.content)) {
-          // Handle array of content blocks
-          for (const block of toolResult.content) {
-            if ((block.type === "text" || block.type === "reasoning") && block.text) {
-              extractedContent.push(block.text)
-            }
-          }
-        }
-      }
-    }
-  }
-
-  const responseText = extractedContent
-    .filter((text) => text.length > 0)
-    .join("\n\n")
-
-  log(`[call_omo_agent] Got response, length: ${responseText.length}`)
-
-  return responseText
-}

package/src/tools/call-omo-agent/message-storage-directory.ts

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

package/src/tools/call-omo-agent/session-creator.ts

@@ -1,70 +0,0 @@
-import type { CallOmoAgentArgs } from "./types"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { subagentSessions, syncSubagentSessions } from "../../features/claude-code-session-state"
-import { log } from "../../shared"
-
-export async function createOrGetSession(
-  args: CallOmoAgentArgs,
-  toolContext: {
-    sessionID: string
-    messageID: string
-    agent: string
-    abort: AbortSignal
-    metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
-  },
-  ctx: PluginInput
-): Promise<{ sessionID: string; isNew: boolean }> {
-  if (args.session_id) {
-    log(`[call_omo_agent] Using existing session: ${args.session_id}`)
-    const sessionResult = await ctx.client.session.get({
-      path: { id: args.session_id },
-    })
-    if (sessionResult.error) {
-      log(`[call_omo_agent] Session get error:`, sessionResult.error)
-      throw new Error(`Failed to get existing session: ${sessionResult.error}`)
-    }
-    return { sessionID: args.session_id, isNew: false }
-  } else {
-    log(`[call_omo_agent] Creating new session with parent: ${toolContext.sessionID}`)
-    const parentSession = await ctx.client.session.get({
-      path: { id: toolContext.sessionID },
-    }).catch((err) => {
-      log(`[call_omo_agent] Failed to get parent session:`, err)
-      return null
-    })
-    log(`[call_omo_agent] Parent session dir: ${parentSession?.data?.directory}, fallback: ${ctx.directory}`)
-    const parentDirectory = parentSession?.data?.directory ?? ctx.directory
-
-    const createResult = await ctx.client.session.create({
-      body: {
-        parentID: toolContext.sessionID,
-        title: `${args.description} (@${args.subagent_type} subagent)`,
-      } as Record<string, unknown>,
-      query: {
-        directory: parentDirectory,
-      },
-    })
-
-    if (createResult.error) {
-      log(`[call_omo_agent] Session create error:`, createResult.error)
-      const errorStr = String(createResult.error)
-      if (errorStr.toLowerCase().includes("unauthorized")) {
-        throw new Error(`Failed to create session (Unauthorized). This may be due to:
-1. OAuth token restrictions (e.g., Claude Code credentials are restricted to Claude Code only)
-2. Provider authentication issues
-3. Session permission inheritance problems
-
-Try using a different provider or API key authentication.
-
-Original error: ${createResult.error}`)
-      }
-      throw new Error(`Failed to create session: ${createResult.error}`)
-    }
-
-    const sessionID = createResult.data.id
-    log(`[call_omo_agent] Created session: ${sessionID}`)
-    subagentSessions.add(sessionID)
-    syncSubagentSessions.add(sessionID)
-    return { sessionID, isNew: true }
-  }
-}

package/src/tools/call-omo-agent/subagent-session-creator.ts

@@ -1,74 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared"
-import { resolveSessionDirectory } from "../../shared"
-import { subagentSessions, syncSubagentSessions } from "../../features/claude-code-session-state"
-import type { CallOmoAgentArgs } from "./types"
-import type { ToolContextWithMetadata } from "./tool-context-with-metadata"
-
-export async function resolveOrCreateSessionId(
-	ctx: PluginInput,
-	args: CallOmoAgentArgs,
-	toolContext: ToolContextWithMetadata,
-): Promise<{ ok: true; sessionID: string } | { ok: false; error: string }> {
-	if (args.session_id) {
-		log(`[call_omo_agent] Using existing session: ${args.session_id}`)
-		const sessionResult = await ctx.client.session.get({
-			path: { id: args.session_id },
-		})
-		if (sessionResult.error) {
-			log("[call_omo_agent] Session get error", { error: sessionResult.error })
-			return {
-				ok: false,
-				error: `Error: Failed to get existing session: ${sessionResult.error}`,
-			}
-		}
-		return { ok: true, sessionID: args.session_id }
-	}
-
-	log(`[call_omo_agent] Creating new session with parent: ${toolContext.sessionID}`)
-	const parentSession = await ctx.client.session
-		.get({ path: { id: toolContext.sessionID } })
-		.catch((err: unknown) => {
-			log("[call_omo_agent] Failed to get parent session", { error: String(err) })
-			return null
-		})
-	const parentDirectory = resolveSessionDirectory({
-		parentDirectory: parentSession?.data?.directory,
-		fallbackDirectory: ctx.directory,
-	})
-
-	const body = {
-		parentID: toolContext.sessionID,
-		title: `${args.description} (@${args.subagent_type} subagent)`,
-	}
-
-	const createResult = await ctx.client.session.create({
-		body,
-		query: { directory: parentDirectory },
-	})
-
-	if (createResult.error) {
-		log("[call_omo_agent] Session create error", { error: createResult.error })
-		const errorStr = String(createResult.error)
-		if (errorStr.toLowerCase().includes("unauthorized")) {
-			return {
-				ok: false,
-				error: `Error: Failed to create session (Unauthorized). This may be due to:
-1. OAuth token restrictions (e.g., Claude Code credentials are restricted to Claude Code only)
-2. Provider authentication issues
-3. Session permission inheritance problems
-
-Try using a different provider or API key authentication.
-
-Original error: ${createResult.error}`,
-			}
-		}
-		return { ok: false, error: `Error: Failed to create session: ${createResult.error}` }
-	}
-
-	const sessionID = createResult.data.id
-	log(`[call_omo_agent] Created session: ${sessionID}`)
-	subagentSessions.add(sessionID)
-	syncSubagentSessions.add(sessionID)
-	return { ok: true, sessionID }
-}

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

@@ -1,148 +0,0 @@
-import type { CallOmoAgentArgs } from "./types"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { subagentSessions, syncSubagentSessions } from "../../features/claude-code-session-state"
-import { clearSessionFallbackChain, setSessionFallbackChain } from "../../hooks/model-fallback/hook"
-import { getAgentToolRestrictions, log } from "../../shared"
-import { applySessionPromptParams } from "../../shared/session-prompt-params-helpers"
-import type { DelegatedModelConfig } from "../../shared/model-resolution-types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { stripAgentListSortPrefix } from "../../shared/agent-display-names"
-import { waitForCompletion } from "./completion-poller"
-import { processMessages } from "./message-processor"
-import { createOrGetSession } from "./session-creator"
-
-type SessionWithPromptAsync = {
-  promptAsync: (opts: { path: { id: string }; body: Record<string, unknown> }) => Promise<unknown>
-}
-
-type ExecuteSyncDeps = {
-  createOrGetSession: typeof createOrGetSession
-  waitForCompletion: typeof waitForCompletion
-  processMessages: typeof processMessages
-  setSessionFallbackChain: typeof setSessionFallbackChain
-  clearSessionFallbackChain: typeof clearSessionFallbackChain
-}
-
-type SpawnReservation = {
-  commit: () => number
-  rollback: () => void
-}
-
-const defaultDeps: ExecuteSyncDeps = {
-  createOrGetSession,
-  waitForCompletion,
-  processMessages,
-  setSessionFallbackChain,
-  clearSessionFallbackChain,
-}
-
-function buildPromptGenerationParams(model: DelegatedModelConfig | undefined): Record<string, unknown> {
-  if (!model) {
-    return {}
-  }
-
-  const promptOptions: Record<string, unknown> = {
-    ...(model.reasoningEffort ? { reasoningEffort: model.reasoningEffort } : {}),
-    ...(model.thinking ? { thinking: model.thinking } : {}),
-  }
-
-  return {
-    ...(model.temperature !== undefined ? { temperature: model.temperature } : {}),
-    ...(model.top_p !== undefined ? { topP: model.top_p } : {}),
-    ...(model.maxTokens !== undefined ? { maxOutputTokens: model.maxTokens } : {}),
-    ...(Object.keys(promptOptions).length > 0 ? { options: promptOptions } : {}),
-  }
-}
-
-export async function executeSync(
-  args: CallOmoAgentArgs,
-  toolContext: {
-    sessionID: string
-    messageID: string
-    agent: string
-    abort: AbortSignal
-    metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void | Promise<void>
-  },
-  ctx: PluginInput,
-  deps: ExecuteSyncDeps = defaultDeps,
-  fallbackChain?: FallbackEntry[],
-  spawnReservation?: SpawnReservation,
-  model?: DelegatedModelConfig,
-): Promise<string> {
-  let sessionID: string | undefined
-  let createdSessionForExecution = false
-  let appliedFallbackChain = false
-
-  try {
-    const session = await deps.createOrGetSession(args, toolContext, ctx)
-    sessionID = session.sessionID
-    createdSessionForExecution = session.isNew
-    subagentSessions.add(sessionID)
-    syncSubagentSessions.add(sessionID)
-
-    if (session.isNew) {
-      spawnReservation?.commit()
-    }
-
-    if (fallbackChain && fallbackChain.length > 0) {
-      deps.setSessionFallbackChain(sessionID, fallbackChain)
-      appliedFallbackChain = true
-    }
-
-    applySessionPromptParams(sessionID, model)
-
-    await Promise.resolve(
-      toolContext.metadata?.({
-        title: args.description,
-        metadata: { sessionId: sessionID },
-      })
-    )
-
-    log(`[call_omo_agent] Sending prompt to session ${sessionID}`)
-    log(`[call_omo_agent] Prompt text:`, args.prompt.substring(0, 100))
-    const normalizedSubagentType = stripAgentListSortPrefix(args.subagent_type)
-
-    try {
-      await (ctx.client.session as unknown as SessionWithPromptAsync).promptAsync({
-        path: { id: sessionID },
-        body: {
-          agent: normalizedSubagentType,
-          tools: {
-            ...getAgentToolRestrictions(normalizedSubagentType),
-            task: false,
-            question: false,
-          },
-          parts: [{ type: "text", text: args.prompt }],
-          ...(model ? { model: { providerID: model.providerID, modelID: model.modelID } } : {}),
-          ...(model?.variant ? { variant: model.variant } : {}),
-          ...buildPromptGenerationParams(model),
-        },
-      })
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error)
-      log(`[call_omo_agent] Prompt error:`, errorMessage)
-      if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
-        return `Error: Agent "${normalizedSubagentType}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.\n\n<task_metadata>\nsession_id: ${sessionID}\n</task_metadata>`
-      }
-      return `Error: Failed to send prompt: ${errorMessage}\n\n<task_metadata>\nsession_id: ${sessionID}\n</task_metadata>`
-    }
-
-    await deps.waitForCompletion(sessionID, toolContext, ctx)
-
-    const responseText = await deps.processMessages(sessionID, ctx)
-
-    return responseText + "\n\n" + ["<task_metadata>", `session_id: ${sessionID}`, "</task_metadata>"].join("\n")
-  } catch (error) {
-    spawnReservation?.rollback()
-    throw error
-  } finally {
-    if (sessionID && appliedFallbackChain) {
-      deps.clearSessionFallbackChain(sessionID)
-    }
-
-    if (sessionID && createdSessionForExecution) {
-      subagentSessions.delete(sessionID)
-      syncSubagentSessions.delete(sessionID)
-    }
-  }
-}

package/src/tools/call-omo-agent/tool-context-with-metadata.ts

@@ -1,10 +0,0 @@
-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/tools.ts

@@ -1,192 +0,0 @@
-import { tool, type PluginInput, type ToolDefinition } from "@opencode-ai/plugin"
-import {
-  CALL_OMO_AGENT_DESCRIPTION,
-  PRIMARY_ALLOWED_AGENTS,
-} from "./constants"
-import type { AllowedAgentType, CallOmoAgentArgs, ToolContextWithMetadata } from "./types"
-import type { BackgroundManager } from "../../features/background-agent"
-import type { CategoriesConfig, AgentOverrides } from "../../config/schema"
-import type { DelegatedModelConfig } from "../../shared/model-resolution-types"
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { AGENT_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
-import { getAgentConfigKey, stripInvisibleAgentCharacters } from "../../shared/agent-display-names"
-import { normalizeFallbackModels } from "../../shared/model-resolver"
-import { buildFallbackChainFromModels } from "../../shared/fallback-chain-from-models"
-import { log } from "../../shared"
-import { CONFIG_BASENAME } from "../../shared/plugin-identity"
-import { parseModelString } from "../delegate-task/model-string-parser"
-import { executeBackground } from "./background-executor"
-import { executeSync } from "./sync-executor"
-import { resolveCallableAgents } from "./agent-resolver"
-
-function resolveModelAndFallbackChain(args: {
-  subagentType: string
-  agentOverrides?: AgentOverrides
-  userCategories?: CategoriesConfig
-}): { model: DelegatedModelConfig | undefined; fallbackChain: FallbackEntry[] | undefined } {
-  const { subagentType, agentOverrides, userCategories } = args
-  const agentConfigKey = getAgentConfigKey(subagentType)
-  const agentRequirement = AGENT_MODEL_REQUIREMENTS[agentConfigKey]
-
-  const agentOverride = agentOverrides?.[agentConfigKey as keyof AgentOverrides]
-    ?? (agentOverrides
-      ? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === agentConfigKey)?.[1]
-      : undefined)
-  const agentCategoryModel = agentOverride?.category
-    ? userCategories?.[agentOverride.category]?.model
-    : undefined
-  const agentCategoryVariant = agentOverride?.category
-    ? userCategories?.[agentOverride.category]?.variant
-    : undefined
-
-  let model: DelegatedModelConfig | undefined
-  if (agentOverride?.model) {
-    const normalized = parseModelString(agentOverride.model)
-    if (normalized) {
-      model = agentOverride.variant ? { ...normalized, variant: agentOverride.variant } : normalized
-      log("[call_omo_agent] Resolved model override from agent config", {
-        agent: subagentType,
-        model: agentOverride.model,
-        variant: agentOverride.variant,
-      })
-    }
-  } else if (agentCategoryModel) {
-    const normalized = parseModelString(agentCategoryModel)
-    if (normalized) {
-      const variantToUse = agentOverride?.variant ?? agentCategoryVariant
-      model = variantToUse ? { ...normalized, variant: variantToUse } : normalized
-      log("[call_omo_agent] Resolved model override from agent category", {
-        agent: subagentType,
-        category: agentOverride?.category,
-        model: agentCategoryModel,
-        variant: variantToUse,
-      })
-    }
-  }
-
-  const normalizedFallbackModels = normalizeFallbackModels(
-    agentOverride?.fallback_models
-    ?? (agentOverride?.category ? userCategories?.[agentOverride.category]?.fallback_models : undefined)
-  )
-  const defaultProviderID = model?.providerID
-    ?? agentRequirement?.fallbackChain?.[0]?.providers?.[0]
-    ?? "opencode"
-  const configuredFallbackChain = buildFallbackChainFromModels(normalizedFallbackModels, defaultProviderID)
-
-  return {
-    model,
-    fallbackChain: configuredFallbackChain ?? agentRequirement?.fallbackChain,
-  }
-}
-
-export function createCallOmoAgent(
-  ctx: PluginInput,
-  backgroundManager: BackgroundManager,
-  disabledAgents: string[] = [],
-  agentOverrides?: AgentOverrides,
-  userCategories?: CategoriesConfig,
-): ToolDefinition {
-  const primaryAgentDescriptions = PRIMARY_ALLOWED_AGENTS.map((name) => {
-    switch (name) {
-      case "researcher":
-        return "- researcher: Canonical agent for codebase exploration and research";
-      case "strategist":
-        return "- strategist: Canonical agent for planning and reasoning";
-      case "coder":
-        return "- coder: Canonical agent for implementation work";
-      case "critic":
-        return "- critic: Canonical agent for review and verification";
-      case "designer":
-        return "- designer: Canonical agent for visual direction, interface design, and creative execution";
-      case "brainstormer":
-        return "- brainstormer: Canonical agent for ideation, option generation, and concept exploration";
-      case "platform-manager":
-        return "- platform-manager: Canonical agent for project setup, continuity, and platform management tasks";
-      case "multimodal":
-        return "- multimodal: Canonical agent for visual and multimodal tasks (runtime display name: Vision)";
-    }
-  }).join("\n");
-
-  const description = CALL_OMO_AGENT_DESCRIPTION.replace(
-    "{primary_agents}",
-    primaryAgentDescriptions,
-  );
-
-  return tool({
-    description,
-    args: {
-      description: tool.schema
-        .string()
-        .describe("A short (3-5 words) description of the task"),
-      prompt: tool.schema
-        .string()
-        .describe("The task for the agent to perform"),
-      subagent_type: tool.schema
-        .string()
-        .describe(
-          "The agent to invoke. Canonical names are preferred; compatibility aliases and custom agents are also accepted.",
-        ),
-      run_in_background: tool.schema
-        .boolean()
-        .describe(
-          "REQUIRED. true: run asynchronously (use background_output to get results), false: run synchronously and wait for completion",
-        ),
-      session_id: tool.schema
-        .string()
-        .describe("Existing Task session to continue")
-        .optional(),
-    },
-    async execute(args: CallOmoAgentArgs, toolContext) {
-      const toolCtx = toolContext as ToolContextWithMetadata;
-      log(
-        `[call_omo_agent] Starting with agent: ${args.subagent_type}, background: ${args.run_in_background}`,
-      );
-
-      const callableAgents = await resolveCallableAgents(ctx.client);
-
-      // Strip ZWSP and case-insensitive agent validation - allows canonical names and compatibility aliases.
-      const strippedAgentType = stripInvisibleAgentCharacters(args.subagent_type)
-      if (
-        !callableAgents.some(
-          (name) => name.toLowerCase() === strippedAgentType.toLowerCase(),
-        )
-      ) {
-        return `Error: Invalid agent type "${args.subagent_type}". Only ${callableAgents.join(", ")} are allowed.`;
-      }
-
-      const normalizedAgent = strippedAgentType.toLowerCase();
-      args = { ...args, subagent_type: normalizedAgent };
-
-      // Check if agent is disabled
-      if (disabledAgents.some((disabled) => stripInvisibleAgentCharacters(disabled).toLowerCase() === normalizedAgent)) {
-        return `Error: Agent "${normalizedAgent}" is disabled via disabled_agents configuration. Remove it from disabled_agents in your ${CONFIG_BASENAME}.json to use it.`
-      }
-
-      const { model: resolvedModel, fallbackChain } = resolveModelAndFallbackChain({
-        subagentType: args.subagent_type,
-        agentOverrides,
-        userCategories,
-      })
-
-      if (args.run_in_background) {
-        if (args.session_id) {
-          return `Error: session_id is not supported in background mode. Use run_in_background=false to continue an existing session.`;
-        }
-        return await executeBackground(args, toolCtx, backgroundManager, ctx.client, fallbackChain, resolvedModel)
-      }
-
-      if (!args.session_id) {
-        let spawnReservation: Awaited<ReturnType<BackgroundManager["reserveSubagentSpawn"]>> | undefined
-        try {
-          spawnReservation = await backgroundManager.reserveSubagentSpawn(toolCtx.sessionID)
-          return await executeSync(args, toolCtx, ctx, undefined, fallbackChain, spawnReservation, resolvedModel)
-        } catch (error) {
-          spawnReservation?.rollback()
-          return `Error: ${error instanceof Error ? error.message : String(error)}`
-        }
-      }
-
-      return await executeSync(args, toolCtx, ctx, undefined, fallbackChain, undefined, resolvedModel)
-    },
-  });
-}

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

@@ -1,34 +0,0 @@
-import type { ALLOWED_AGENTS } from "./constants"
-
-export type AllowedAgentType = (typeof ALLOWED_AGENTS)[number]
-
-export interface CallOmoAgentArgs {
-  description: string
-  prompt: string
-  subagent_type: string
-  run_in_background: boolean
-  session_id?: string
-}
-
-export interface CallOmoAgentSyncResult {
-  title: string
-  metadata: {
-    summary?: Array<{
-      id: string
-      tool: string
-      state: {
-        status: string
-        title?: string
-      }
-    }>
-    sessionId: string
-  }
-  output: string
-}
-export type ToolContextWithMetadata = {
-  sessionID: string
-  messageID: string
-  agent: string
-  abort: AbortSignal
-  metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
-}