@oh-my-tool/cli 0.2.0 → 0.3.0

package/src/cli/parseArgs.ts

@@ -1,44 +1,62 @@
-export interface ParsedArgs {
-  positional: string[];
-  keyValues: Record<string, string>;
-  flags: string[];
-  options: Record<string, string>;
-}
-
-export function parseArgs(argv: string[]): ParsedArgs {
-  const positional: string[] = [];
-  const keyValues: Record<string, string> = {};
-  const flags: string[] = [];
-  const options: Record<string, string> = {};
-  for (const arg of argv) {
-    if (arg.startsWith("--")) {
-      const option = arg.slice(2);
-      const eq = option.indexOf("=");
-      if (eq > 0) {
-        options[option.slice(0, eq)] = option.slice(eq + 1);
-      } else {
-        flags.push(option);
-      }
-    } else {
-      const eq = arg.indexOf("=");
-      if (eq > 0) {
-        keyValues[arg.slice(0, eq)] = arg.slice(eq + 1);
-      } else {
-        positional.push(arg);
-      }
-    }
-  }
-  return { positional, keyValues, flags, options };
-}
-
-export function coerceInput(input: Record<string, unknown>): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(input)) {
-    if (typeof v === "string" && /^-?\d+$/.test(v)) {
-      out[k] = Number(v);
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
-}
+export interface ParsedArgs {
+  positional: string[];
+  keyValues: Record<string, string>;
+  flags: string[];
+  options: Record<string, string>;
+}
+
+export type ParsedMcpCommand =
+  | { readonly action: "list" }
+  | { readonly action: "auth" | "logout"; readonly serverId: string };
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  const positional: string[] = [];
+  const keyValues: Record<string, string> = {};
+  const flags: string[] = [];
+  const options: Record<string, string> = {};
+  for (const arg of argv) {
+    if (arg.startsWith("--")) {
+      const option = arg.slice(2);
+      const eq = option.indexOf("=");
+      if (eq > 0) {
+        options[option.slice(0, eq)] = option.slice(eq + 1);
+      } else {
+        flags.push(option);
+      }
+    } else {
+      const eq = arg.indexOf("=");
+      if (eq > 0) {
+        keyValues[arg.slice(0, eq)] = arg.slice(eq + 1);
+      } else {
+        positional.push(arg);
+      }
+    }
+  }
+  return { positional, keyValues, flags, options };
+}
+
+export function parseMcpCommand(args: ParsedArgs): ParsedMcpCommand | undefined {
+  if (args.positional[0] !== "mcp") return undefined;
+  const action = args.positional[1];
+  const serverId = args.positional[2];
+  if (action === "list") return args.positional.length === 2 ? { action } : undefined;
+  if (
+    (action !== "auth" && action !== "logout") ||
+    serverId === undefined ||
+    serverId.length === 0 ||
+    args.positional.length !== 3
+  ) return undefined;
+  return { action, serverId };
+}
+
+export function coerceInput(input: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (typeof v === "string" && /^-?\d+$/.test(v)) {
+      out[k] = Number(v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}

package/src/config/config.ts

@@ -1,63 +1,155 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-export interface ConnectionConfig {
-  environment: string;
-  host: string;
-  port: number;
-  database: string;
-  username: string;
-  secret: string;
-  tls: boolean;
-}
-
-export interface Config {
-  extensions: Record<string, { connections: Record<string, ConnectionConfig> }>;
-}
-
-export function loadConfig(homeDir: string): Config {
-  const path = join(homeDir, "config.toml");
-  if (!existsSync(path)) {
-    return { extensions: {} };
-  }
-  const raw = readFileSync(path, "utf8");
-  const parsed = Bun.TOML.parse(raw) as Record<string, unknown>;
-
-  const extensions: Config["extensions"] = {};
-  const extSection = (parsed as Record<string, any>)["extensions"];
-  if (extSection && typeof extSection === "object") {
-    for (const [extId, extVal] of Object.entries(extSection)) {
-      const connections: Record<string, ConnectionConfig> = {};
-      const connSection = (extVal as any)?.["connections"];
-      if (connSection && typeof connSection === "object") {
-        for (const [name, rawConn] of Object.entries(connSection)) {
-          const rc = rawConn as Record<string, any>;
-          connections[name] = {
-            environment: String(rc.environment ?? ""),
-            host: String(rc.host ?? ""),
-            port: Number(rc.port ?? 3306),
-            database: String(rc.database ?? ""),
-            username: String(rc.username ?? ""),
-            secret: String(rc.secret ?? ""),
-            tls: Boolean(rc.tls ?? false),
-          };
-        }
-      }
-      extensions[extId] = { connections };
-    }
-  }
-  return { extensions };
-}
-
-export function getConnectionConfig(
-  cfg: Config,
-  extensionId: string,
-  connection: string,
-): ConnectionConfig | undefined {
-  return cfg.extensions[extensionId]?.connections[connection];
-}
-
-export function listConnections(cfg: Config, extensionId: string): string[] {
-  const conns = cfg.extensions[extensionId]?.connections ?? {};
-  return Object.keys(conns);
-}
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { RuntimeError } from "../runtime/errors";
+
+export interface ConnectionConfig {
+  environment: string;
+  host: string;
+  port: number;
+  database: string;
+  username: string;
+  secret: string;
+  tls: boolean;
+}
+
+export interface McpCommonServerConfig { readonly enabled: true; readonly namespace: string; }
+export interface McpStdioServerConfig extends McpCommonServerConfig {
+  readonly transport: "stdio"; readonly command: string; readonly args: readonly string[]; readonly cwd?: string;
+  readonly env: Readonly<Record<string, string>>; readonly secretEnv: Readonly<Record<string, string>>;
+}
+export interface McpHttpServerConfig extends McpCommonServerConfig {
+  readonly transport: "streamable-http"; readonly url: string; readonly headers: Readonly<Record<string, string>>;
+  readonly secretHeaders: Readonly<Record<string, string>>; readonly auth: McpHttpAuthConfig;
+}
+export type McpHttpAuthConfig =
+  | { readonly type: "none" }
+  | { readonly type: "bearer"; readonly tokenSecret: string }
+  | { readonly type: "oauth"; readonly scopes: readonly string[]; readonly callbackPort: number; readonly clientId?: string; readonly clientSecretSecret?: string; readonly tokenEndpointAuthMethod: "none" | "client_secret_basic" | "client_secret_post" };
+export type McpEnabledServerConfig = McpStdioServerConfig | McpHttpServerConfig;
+export interface McpDisabledServerConfig {
+  readonly enabled: false;
+  readonly namespace: string;
+  readonly transport: "disabled";
+}
+export type McpServerConfig = McpEnabledServerConfig | McpDisabledServerConfig;
+export interface Config {
+  extensions: Record<string, { connections: Record<string, ConnectionConfig> }>;
+  mcp: { servers: Record<string, McpServerConfig> };
+}
+
+function invalid(path: string, reason: string): never { throw new RuntimeError("MCP_INVALID_CONFIG", `${path}: ${reason}`); }
+
+function parseStringMap(value: unknown, path: string): Record<string, string> {
+  if (value === undefined) return {};
+  if (value === null || typeof value !== "object" || Array.isArray(value)) invalid(path, "must be a table");
+  const result: Record<string, string> = {};
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    if (typeof entry !== "string") invalid(`${path}.${key}`, "must be a string");
+    result[key] = entry;
+  }
+  return result;
+}
+
+function parseStringArray(value: unknown, path: string): string[] {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) invalid(path, "must be an array of strings");
+  return [...value];
+}
+
+function assertMcpName(value: string, path: string): void {
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(value)) {
+    invalid(path, "must contain only lowercase letters, numbers, underscores, and hyphens");
+  }
+}
+
+function requiredString(value: unknown, path: string): string {
+  if (typeof value !== "string" || value.length === 0) invalid(path, "must be a non-empty string");
+  return value;
+}
+
+function parseMcpServer(id: string, value: unknown): McpServerConfig {
+  const path = `mcp.servers.${id}`;
+  assertMcpName(id, path);
+  if (value === null || typeof value !== "object" || Array.isArray(value)) invalid(path, "must be a table");
+  const raw = value as Record<string, unknown>;
+  const enabled = raw.enabled === undefined ? true : raw.enabled;
+  if (typeof enabled !== "boolean") invalid(`${path}.enabled`, "must be a boolean");
+  if (!enabled) return { enabled: false, namespace: id, transport: "disabled" };
+  const namespace = raw.namespace === undefined ? id : requiredString(raw.namespace, `${path}.namespace`);
+  assertMcpName(namespace, `${path}.namespace`);
+  if (namespace === "native" || namespace === "mcp") invalid(`${path}.namespace`, "is reserved");
+
+  if (raw.transport === "stdio") {
+    if (raw.auth !== undefined) invalid(`${path}.auth`, "is only supported for HTTP servers");
+    const command = requiredString(raw.command, `${path}.command`);
+    const args = parseStringArray(raw.args, `${path}.args`);
+    const cwd = raw.cwd === undefined ? undefined : requiredString(raw.cwd, `${path}.cwd`);
+    return { enabled, transport: "stdio", command, args, ...(cwd === undefined ? {} : { cwd }), namespace, env: parseStringMap(raw.env, `${path}.env`), secretEnv: parseStringMap(raw.secretEnv, `${path}.secretEnv`) };
+  }
+  if (raw.transport !== "streamable-http") invalid(`${path}.transport`, "must be stdio or streamable-http");
+  const url = requiredString(raw.url, `${path}.url`);
+  try {
+    const parsedUrl = new URL(url);
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") invalid(`${path}.url`, "must use http or https");
+  } catch { invalid(`${path}.url`, "must be a valid HTTP(S) URL"); }
+  const headers = parseStringMap(raw.headers, `${path}.headers`);
+  const secretHeaders = parseStringMap(raw.secretHeaders, `${path}.secretHeaders`);
+  const secretHeaderNames = new Set(Object.keys(secretHeaders).map((key) => key.toLowerCase()));
+  for (const key of Object.keys(headers)) {
+    if (secretHeaderNames.has(key.toLowerCase())) invalid(`${path}.headers`, "must not overlap secretHeaders");
+  }
+  const hasAuthorizationHeader = [...Object.keys(headers), ...Object.keys(secretHeaders)]
+    .some((key) => key.toLowerCase() === "authorization");
+  if (hasAuthorizationHeader && raw.bearerTokenSecret !== undefined) {
+    invalid(`${path}.bearerTokenSecret`, "must not be combined with Authorization");
+  }
+  const authMode = raw.auth === undefined ? "none" : raw.auth;
+  if (hasAuthorizationHeader && (authMode === "bearer" || authMode === "oauth")) {
+    invalid(`${path}.headers`, "must not configure Authorization when bearer or oauth auth is enabled");
+  }
+  if (authMode === "none") return { enabled, transport: "streamable-http", url, namespace, headers, secretHeaders, auth: { type: "none" } };
+  if (authMode === "bearer") return { enabled, transport: "streamable-http", url, namespace, headers, secretHeaders, auth: { type: "bearer", tokenSecret: requiredString(raw.bearerTokenSecret, `${path}.bearerTokenSecret`) } };
+  if (authMode !== "oauth") invalid(`${path}.auth`, "must be none, bearer, or oauth");
+  const scopes = parseStringArray(raw.oauthScopes, `${path}.oauthScopes`);
+  const callbackPort = raw.oauthCallbackPort === undefined ? 0 : raw.oauthCallbackPort;
+  if (typeof callbackPort !== "number" || !Number.isInteger(callbackPort) || (callbackPort !== 0 && (callbackPort < 1024 || callbackPort > 65535))) invalid(`${path}.oauthCallbackPort`, "must be 0 or an integer from 1024 through 65535");
+  const clientId = raw.oauthClientId === undefined ? undefined : requiredString(raw.oauthClientId, `${path}.oauthClientId`);
+  const clientSecretSecret = raw.oauthClientSecretSecret === undefined ? undefined : requiredString(raw.oauthClientSecretSecret, `${path}.oauthClientSecretSecret`);
+  if (clientSecretSecret !== undefined && clientId === undefined) invalid(`${path}.oauthClientSecretSecret`, "requires oauthClientId");
+  const tokenEndpointAuthMethod = raw.oauthTokenEndpointAuthMethod === undefined ? "none" : raw.oauthTokenEndpointAuthMethod;
+  if (tokenEndpointAuthMethod !== "none" && tokenEndpointAuthMethod !== "client_secret_basic" && tokenEndpointAuthMethod !== "client_secret_post") invalid(`${path}.oauthTokenEndpointAuthMethod`, "must be none, client_secret_basic, or client_secret_post");
+  if (tokenEndpointAuthMethod !== "none" && clientSecretSecret === undefined) invalid(`${path}.oauthTokenEndpointAuthMethod`, "requires oauthClientSecretSecret");
+  if (tokenEndpointAuthMethod === "none" && clientSecretSecret !== undefined) invalid(`${path}.oauthTokenEndpointAuthMethod`, "cannot be none with a client secret");
+  return { enabled, transport: "streamable-http", url, namespace, headers, secretHeaders, auth: { type: "oauth", scopes, callbackPort, ...(clientId === undefined ? {} : { clientId }), ...(clientSecretSecret === undefined ? {} : { clientSecretSecret }), tokenEndpointAuthMethod } };
+}
+
+export function loadConfig(homeDir: string): Config {
+  const path = join(homeDir, "config.toml");
+  if (!existsSync(path)) return { extensions: {}, mcp: { servers: {} } };
+  const parsed = Bun.TOML.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+  const extensions: Config["extensions"] = {};
+  const extSection = parsed.extensions;
+  if (extSection && typeof extSection === "object") for (const [extId, extVal] of Object.entries(extSection)) {
+    const connections: Record<string, ConnectionConfig> = {};
+    const connSection = (extVal as Record<string, any>)?.connections;
+    if (connSection && typeof connSection === "object") for (const [name, rawConn] of Object.entries(connSection)) {
+      const rc = rawConn as Record<string, any>;
+      connections[name] = { environment: String(rc.environment ?? ""), host: String(rc.host ?? ""), port: Number(rc.port ?? 3306), database: String(rc.database ?? ""), username: String(rc.username ?? ""), secret: String(rc.secret ?? ""), tls: Boolean(rc.tls ?? false) };
+    }
+    extensions[extId] = { connections };
+  }
+  const servers: Record<string, McpServerConfig> = {};
+  const serverSection = (parsed.mcp as Record<string, unknown> | undefined)?.servers;
+  if (serverSection !== undefined) {
+    if (serverSection === null || typeof serverSection !== "object" || Array.isArray(serverSection)) {
+      invalid("mcp.servers", "must be a table");
+    }
+    for (const [id, value] of Object.entries(serverSection)) {
+      servers[id] = parseMcpServer(id, value);
+    }
+  }
+  return { extensions, mcp: { servers } };
+}
+
+export function getConnectionConfig(cfg: Config, extensionId: string, connection: string): ConnectionConfig | undefined { return cfg.extensions[extensionId]?.connections[connection]; }
+export function listConnections(cfg: Config, extensionId: string): string[] { return Object.keys(cfg.extensions[extensionId]?.connections ?? {}); }

package/src/core/executor.ts

@@ -1,84 +1,84 @@
-import type { Logger, SecretStore, ToolContext, ToolResult } from "@oh-my-tool/sdk";
-import { ToolError } from "@oh-my-tool/sdk";
-import type { Config } from "../config/config";
-import { getConnectionConfig } from "../config/config";
-import { resolveTool, OmtError, type Registry } from "./registry";
-import { validateInput, type Schema } from "./schema";
-import { validateConnectionInput, applyLimits, PolicyError } from "../policy/policy";
-import { loadExtension } from "../extension/loader";
-import type { OmtResult } from "./result";
-
-const noopLogger: Logger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-};
-
-export interface ExecutorDeps {
-  registry: Registry;
-  config: Config;
-  secrets: SecretStore;
-  logger?: Logger;
-}
-
-function hasConnection(schema: Schema | undefined): boolean {
-  return Boolean(schema?.properties && "connection" in schema.properties);
-}
-
-export async function executeTool(
-  deps: ExecutorDeps,
-  toolName: string,
-  rawInput: Record<string, unknown>,
-): Promise<OmtResult> {
-  const started = Date.now();
-  try {
-    const { extension, tool } = resolveTool(deps.registry, toolName);
-    const schema = tool.inputSchema as Schema | undefined;
-
-    const limits = applyLimits(rawInput);
-    const normalized = { ...rawInput, maxRows: limits.maxRows, timeoutMs: limits.timeoutMs };
-
-    const needsConnection = hasConnection(schema) || "connection" in normalized;
-    if (needsConnection) {
-      validateConnectionInput(normalized, deps.config, extension.id);
-    }
-
-    const input = validateInput(schema, normalized);
-
-    const connectionCfg = needsConnection
-      ? getConnectionConfig(deps.config, extension.id, String(input.connection))
-      : undefined;
-
-    const ctx: ToolContext = {
-      toolName,
-      logger: deps.logger ?? noopLogger,
-      config: (connectionCfg ?? {}) as Record<string, unknown>,
-      secrets: deps.secrets,
-    };
-
-    const def = await loadExtension(extension);
-    const handler = def.handlers[toolName];
-    if (!handler) {
-      throw new OmtError("HANDLER_MISSING", `no handler for ${toolName}`);
-    }
-
-    const result: ToolResult = await handler(ctx, input);
-    const durationMs = Date.now() - started;
-    return {
-      ok: true,
-      tool: toolName,
-      data: result.data,
-      meta: { durationMs, ...(result.meta ?? {}) },
-    };
-  } catch (e) {
-    const durationMs = Date.now() - started;
-    if (e instanceof PolicyError) {
-      return { ok: false, tool: toolName, error: { code: "POLICY_VIOLATION", message: e.message } };
-    }
-    if (e instanceof ToolError) {
-      return { ok: false, tool: toolName, error: { code: e.code, message: e.message } };
-    }
+import type { Logger, SecretStore, ToolContext, ToolResult } from "@oh-my-tool/sdk";
+import { ToolError } from "@oh-my-tool/sdk";
+import type { Config } from "../config/config";
+import { getConnectionConfig } from "../config/config";
+import { resolveTool, OmtError, type Registry } from "./registry";
+import { validateInput, type Schema } from "./schema";
+import { validateConnectionInput, applyLimits, PolicyError } from "../policy/policy";
+import { loadExtension } from "../extension/loader";
+import type { OmtResult } from "./result";
+
+const noopLogger: Logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+};
+
+export interface ExecutorDeps {
+  registry: Registry;
+  config: Config;
+  secrets: SecretStore;
+  logger?: Logger;
+}
+
+function hasConnection(schema: Schema | undefined): boolean {
+  return Boolean(schema?.properties && "connection" in schema.properties);
+}
+
+export async function executeTool(
+  deps: ExecutorDeps,
+  toolName: string,
+  rawInput: Record<string, unknown>,
+): Promise<OmtResult> {
+  const started = Date.now();
+  try {
+    const { extension, tool } = resolveTool(deps.registry, toolName);
+    const schema = tool.inputSchema as Schema | undefined;
+
+    const limits = applyLimits(rawInput);
+    const normalized = { ...rawInput, maxRows: limits.maxRows, timeoutMs: limits.timeoutMs };
+
+    const needsConnection = hasConnection(schema) || "connection" in normalized;
+    if (needsConnection) {
+      validateConnectionInput(normalized, deps.config, extension.id);
+    }
+
+    const input = validateInput(schema, normalized);
+
+    const connectionCfg = needsConnection
+      ? getConnectionConfig(deps.config, extension.id, String(input.connection))
+      : undefined;
+
+    const ctx: ToolContext = {
+      toolName,
+      logger: deps.logger ?? noopLogger,
+      config: (connectionCfg ?? {}) as Record<string, unknown>,
+      secrets: deps.secrets,
+    };
+
+    const def = await loadExtension(extension);
+    const handler = def.handlers[toolName];
+    if (!handler) {
+      throw new OmtError("HANDLER_MISSING", `no handler for ${toolName}`);
+    }
+
+    const result: ToolResult = await handler(ctx, input);
+    const durationMs = Date.now() - started;
+    return {
+      ok: true,
+      tool: toolName,
+      data: result.data,
+      meta: { durationMs, ...(result.meta ?? {}) },
+    };
+  } catch (e) {
+    const durationMs = Date.now() - started;
+    if (e instanceof PolicyError) {
+      return { ok: false, tool: toolName, error: { code: "POLICY_VIOLATION", message: e.message } };
+    }
+    if (e instanceof ToolError) {
+      return { ok: false, tool: toolName, error: { code: e.code, message: e.message } };
+    }
     if (e instanceof OmtError) {
       return { ok: false, tool: toolName, error: { code: e.code, message: e.message } };
     }
@@ -89,11 +89,11 @@ export async function executeTool(
         error: { code: (e as { code: string }).code, message: e instanceof Error ? e.message : String(e) },
       };
     }
-    return {
-      ok: false,
-      tool: toolName,
-      error: { code: "EXECUTION_FAILED", message: e instanceof Error ? e.message : String(e) },
-    };
-  }
-}
-
+    return {
+      ok: false,
+      tool: toolName,
+      error: { code: "EXECUTION_FAILED", message: e instanceof Error ? e.message : String(e) },
+    };
+  }
+}
+

package/src/core/registry.ts

@@ -1,33 +1,33 @@
-import type { ExtensionManifest } from "@oh-my-tool/sdk";
-import type { InstalledExtension } from "../extension/discovery";
-
+import type { ExtensionManifest } from "@oh-my-tool/sdk";
+import type { InstalledExtension } from "../extension/discovery";
+
 import { RuntimeError as OmtError } from "../runtime/errors";
 export { OmtError };
-
-export interface Registry {
-  byTool: Map<string, { extension: InstalledExtension; tool: ExtensionManifest["tools"][number] }>;
-  byId: Map<string, InstalledExtension>;
-}
-
-export function createRegistry(installed: InstalledExtension[]): Registry {
-  const byTool = new Map();
-  const byId = new Map();
-  for (const ext of installed) {
-    byId.set(ext.id, ext);
-    for (const tool of ext.manifest.tools) {
-      byTool.set(tool.name, { extension: ext, tool });
-    }
-  }
-  return { byTool, byId };
-}
-
-export function resolveTool(
-  reg: Registry,
-  toolName: string,
-): { extension: InstalledExtension; tool: ExtensionManifest["tools"][number] } {
-  const hit = reg.byTool.get(toolName);
-  if (!hit) {
-    throw new OmtError("UNKNOWN_TOOL", `unknown tool '${toolName}'`);
-  }
-  return hit;
-}
+
+export interface Registry {
+  byTool: Map<string, { extension: InstalledExtension; tool: ExtensionManifest["tools"][number] }>;
+  byId: Map<string, InstalledExtension>;
+}
+
+export function createRegistry(installed: InstalledExtension[]): Registry {
+  const byTool = new Map();
+  const byId = new Map();
+  for (const ext of installed) {
+    byId.set(ext.id, ext);
+    for (const tool of ext.manifest.tools) {
+      byTool.set(tool.name, { extension: ext, tool });
+    }
+  }
+  return { byTool, byId };
+}
+
+export function resolveTool(
+  reg: Registry,
+  toolName: string,
+): { extension: InstalledExtension; tool: ExtensionManifest["tools"][number] } {
+  const hit = reg.byTool.get(toolName);
+  if (!hit) {
+    throw new OmtError("UNKNOWN_TOOL", `unknown tool '${toolName}'`);
+  }
+  return hit;
+}

package/src/core/result.ts

@@ -1,14 +1,14 @@
-export interface OmtOk {
-  ok: true;
-  tool: string;
-  data: unknown;
-  meta: Record<string, unknown>;
-}
-
-export interface OmtErr {
-  ok: false;
-  tool: string;
-  error: { code: string; message: string };
-}
-
-export type OmtResult = OmtOk | OmtErr;
+export interface OmtOk {
+  ok: true;
+  tool: string;
+  data: unknown;
+  meta: Record<string, unknown>;
+}
+
+export interface OmtErr {
+  ok: false;
+  tool: string;
+  error: { code: string; message: string; details?: unknown };
+}
+
+export type OmtResult = OmtOk | OmtErr;