@otto-code/protocol 0.5.0

package/dist/tool-call-display.js

@@ -0,0 +1,135 @@
+import { getOttoToolLeafName, isOttoToolName } from "./tool-name-normalization.js";
+import { stripCwdPrefix } from "./path-utils.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function humanizeToolName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return name;
+    }
+    if (isOttoToolName(trimmed)) {
+        const leaf = getOttoToolLeafName(trimmed);
+        if (leaf) {
+            return humanizeToolName(leaf);
+        }
+    }
+    if (/[:./]/.test(trimmed) || trimmed.includes("__")) {
+        return trimmed;
+    }
+    return trimmed
+        .replace(/[._-]+/g, " ")
+        .split(" ")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
+        .join(" ");
+}
+function formatErrorText(error) {
+    if (error === null || error === undefined) {
+        return undefined;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (isRecord(error) && typeof error.content === "string") {
+        return error.content;
+    }
+    try {
+        return JSON.stringify(error, null, 2);
+    }
+    catch {
+        return String(error);
+    }
+}
+function buildFilePathDisplay(displayName, filePath, cwd) {
+    return {
+        displayName,
+        summary: stripCwdPrefix(filePath, cwd),
+    };
+}
+function buildCanonicalDetailDisplay(input) {
+    switch (input.detail.type) {
+        case "shell":
+            return {
+                displayName: "Shell",
+                summary: input.detail.command,
+            };
+        case "read":
+            return buildFilePathDisplay("Read", input.detail.filePath, input.cwd);
+        case "edit":
+            return buildFilePathDisplay("Edit", input.detail.filePath, input.cwd);
+        case "write":
+            return buildFilePathDisplay("Write", input.detail.filePath, input.cwd);
+        case "search":
+            return {
+                displayName: "Search",
+                summary: input.detail.query,
+            };
+        case "fetch":
+            return {
+                displayName: "Fetch",
+                summary: input.detail.url,
+            };
+        case "worktree_setup":
+            return {
+                displayName: "Worktree Setup",
+                summary: input.detail.branchName,
+            };
+        case "sub_agent":
+            return {
+                displayName: readString(input.detail.subAgentType) ?? "Task",
+                summary: readString(input.detail.description),
+            };
+        case "plain_text":
+            return {
+                summary: input.detail.label,
+            };
+        case "plan":
+            return {
+                displayName: "Plan",
+            };
+        case "unknown":
+            return {};
+        default:
+            throw new Error("unreachable");
+    }
+}
+function buildUnknownDetailOverride(input) {
+    const lowerName = input.name.trim().toLowerCase();
+    if (input.detail.type === "unknown" && lowerName === "task") {
+        return {
+            displayName: "Task",
+            summary: isRecord(input.metadata) ? readString(input.metadata.subAgentActivity) : undefined,
+        };
+    }
+    if (input.detail.type === "unknown" && lowerName === "thinking") {
+        return {
+            displayName: "Thinking",
+        };
+    }
+    if (lowerName === "terminal") {
+        return {
+            displayName: "Terminal",
+            summary: input.detail.type === "plain_text" ? readString(input.detail.label) : undefined,
+        };
+    }
+    return {};
+}
+export function buildToolCallDisplayModel(input) {
+    const canonicalDisplay = buildCanonicalDetailDisplay(input);
+    const unknownDetailOverride = buildUnknownDetailOverride(input);
+    const displayName = unknownDetailOverride.displayName ??
+        canonicalDisplay.displayName ??
+        humanizeToolName(input.name);
+    const summary = unknownDetailOverride.summary ?? canonicalDisplay.summary;
+    const errorText = input.status === "failed" ? formatErrorText(input.error) : undefined;
+    return {
+        displayName,
+        ...(summary ? { summary } : {}),
+        ...(errorText ? { errorText } : {}),
+    };
+}
+//# sourceMappingURL=tool-call-display.js.map

package/dist/tool-name-normalization.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeToolName(name: string): string;
+export declare function tokenizeToolName(name: string): string[];
+export declare function getToolLeafName(name: string): string | null;
+export declare function isSpeakToolName(name: string): boolean;
+export declare function isLikelyNamespacedToolName(name: string): boolean;
+export declare function isOttoToolName(name: string): boolean;
+export declare function getOttoToolLeafName(name: string): string | null;
+export declare function isLikelyExternalToolName(name: string): boolean;
+//# sourceMappingURL=tool-name-normalization.d.ts.map

package/dist/tool-name-normalization.js

@@ -0,0 +1,82 @@
+const TOOL_TOKEN_REGEX = /[a-z0-9]+/g;
+const STANDARD_NAMESPACE_SEPARATOR_REGEX = /[.:/]/;
+export function normalizeToolName(name) {
+    return name.trim().toLowerCase();
+}
+export function tokenizeToolName(name) {
+    const normalized = normalizeToolName(name);
+    return normalized.match(TOOL_TOKEN_REGEX) ?? [];
+}
+export function getToolLeafName(name) {
+    const tokens = tokenizeToolName(name);
+    return tokens.length > 0 ? tokens[tokens.length - 1] : null;
+}
+export function isSpeakToolName(name) {
+    return getToolLeafName(name) === "speak";
+}
+export function isLikelyNamespacedToolName(name) {
+    const normalized = normalizeToolName(name);
+    if (STANDARD_NAMESPACE_SEPARATOR_REGEX.test(normalized)) {
+        return true;
+    }
+    if (!normalized.includes("__")) {
+        return false;
+    }
+    // Keep `__` handling strict to avoid false positives on arbitrary custom names.
+    const segments = normalized.split("__").filter((segment) => segment.length > 0);
+    if (segments.length >= 3) {
+        return true;
+    }
+    if (segments.length === 2 && segments[1].includes("_")) {
+        return true;
+    }
+    return false;
+}
+export function isOttoToolName(name) {
+    const normalized = normalizeToolName(name);
+    if (isSpeakToolName(normalized)) {
+        return false;
+    }
+    if (normalized.includes("__")) {
+        const segments = normalized.split("__").filter((s) => s.length > 0);
+        return (segments.length >= 3 &&
+            segments[0] === "mcp" &&
+            (segments[1] === "otto" || segments[1].startsWith("otto_")));
+    }
+    if (normalized.includes(".")) {
+        const firstSegment = normalized.split(".")[0];
+        return firstSegment === "otto" || firstSegment.startsWith("otto_");
+    }
+    return false;
+}
+export function getOttoToolLeafName(name) {
+    const normalized = normalizeToolName(name);
+    if (normalized.includes("__")) {
+        const segments = normalized.split("__").filter((s) => s.length > 0);
+        if (segments.length >= 3 &&
+            segments[0] === "mcp" &&
+            (segments[1] === "otto" || segments[1].startsWith("otto_"))) {
+            return segments.slice(2).join("__");
+        }
+        return null;
+    }
+    if (normalized.includes(".")) {
+        const firstSegment = normalized.split(".")[0];
+        if (firstSegment === "otto" || firstSegment.startsWith("otto_")) {
+            return normalized.split(".").slice(1).join(".");
+        }
+        return null;
+    }
+    return null;
+}
+export function isLikelyExternalToolName(name) {
+    const normalized = normalizeToolName(name);
+    if (!normalized) {
+        return false;
+    }
+    if (isSpeakToolName(normalized)) {
+        return true;
+    }
+    return isLikelyNamespacedToolName(normalized);
+}
+//# sourceMappingURL=tool-name-normalization.js.map