@anhlp/alp-runtime 0.0.0-stage → 0.0.1-beta.3

package/dist/tool-detail.js

@@ -0,0 +1,332 @@
+// packages/runtime/src/tool-detail.ts
+var DETAIL_TEXT_CHARS = 65536;
+var DETAIL_FILE_PATHS = 200;
+var DETAIL_WEB_RESULTS = 50;
+var ERROR_CHARS = 2e3;
+var TOOL_FAILED = "Tool call failed";
+var DETAIL_TYPES = ["shell", "read", "edit", "write", "search", "fetch", "sub_agent", "plan", "plain_text", "unknown"];
+function clipText(text, max = DETAIL_TEXT_CHARS) {
+  if (text.length <= max) return text;
+  const marker = /\n… \(\d+ more characters\)$/.exec(text);
+  if (marker && marker.index <= max) return text;
+  const end = /[\uD800-\uDBFF]/.test(text[max - 1] ?? "") ? max - 1 : max;
+  return `${text.slice(0, end)}
+\u2026 (${text.length - end} more characters)`;
+}
+function boundDetail(detail) {
+  if (detail.type === "shell" || detail.type === "unknown") return detail;
+  const bounded = {};
+  let cut = false;
+  for (const [key, value] of Object.entries(detail)) {
+    if (value === void 0) continue;
+    if (typeof value === "string") bounded[key] = key === "type" ? value : clipText(value);
+    else if (key === "filePaths" && Array.isArray(value)) {
+      bounded[key] = value.slice(0, DETAIL_FILE_PATHS).map((entry) => clipText(String(entry)));
+      cut = value.length > DETAIL_FILE_PATHS;
+    } else if (key === "webResults" && Array.isArray(value)) {
+      bounded[key] = value.slice(0, DETAIL_WEB_RESULTS).map((entry) => ({ title: clipText(entry.title), url: clipText(entry.url) }));
+    } else bounded[key] = value;
+  }
+  if (cut) bounded.truncated = true;
+  return bounded;
+}
+function toolError(text) {
+  const value = typeof text === "string" ? text.trim().replace(/^<tool_use_error>([\s\S]*)<\/tool_use_error>$/, "$1").trim() : "";
+  return value ? clipText(value, ERROR_CHARS) : TOOL_FAILED;
+}
+var str = (value) => typeof value === "string" && value.trim() ? value : void 0;
+var int = (value) => typeof value === "number" && Number.isInteger(value) ? value : void 0;
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var pathOf = (input) => str(input?.file_path) ?? str(input?.filePath) ?? str(input?.path) ?? str(input?.notebook_path) ?? str(input?.AbsolutePath) ?? str(input?.TargetFile);
+var defined = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+var typed = (detail) => boundDetail(defined(detail));
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = content.map((part) => typeof part === "string" ? part : typeof part?.text === "string" ? part.text : "").filter(Boolean);
+    return parts.length ? parts.join("\n") : void 0;
+  }
+  return void 0;
+}
+var READ_GUTTER = /^\s*(\d+)(?:\t|→)(.*)$/;
+function stripReadGutter(text) {
+  const body = text.replace(/\r\n/g, "\n").replace(/\n*<system-reminder>[\s\S]*?<\/system-reminder>\s*$/g, "");
+  const out = [];
+  let start;
+  let previous;
+  for (const line of body.split("\n")) {
+    if (!line) {
+      out.push(line);
+      continue;
+    }
+    const match = READ_GUTTER.exec(line);
+    if (!match) return void 0;
+    const number = Number.parseInt(match[1], 10);
+    if (previous !== void 0 && number !== previous + 1) return void 0;
+    start ??= number;
+    previous = number;
+    out.push(match[2]);
+  }
+  return start === void 0 ? void 0 : { content: out.join("\n"), startLine: start };
+}
+function structuredPatch(patch) {
+  if (!Array.isArray(patch) || !patch.length) return void 0;
+  const hunks = patch.map((hunk) => {
+    const lines = Array.isArray(hunk?.lines) ? hunk.lines.map(String) : [];
+    return [`@@ -${hunk?.oldStart ?? 0},${hunk?.oldLines ?? 0} +${hunk?.newStart ?? 0},${hunk?.newLines ?? 0} @@`, ...lines].join("\n");
+  });
+  return `${hunks.join("\n")}
+`;
+}
+function replacementsDiff(edits) {
+  const side = (text, mark) => String(text ?? "").split("\n").map((line) => `${mark}${line}`);
+  return `${edits.map((edit) => ["@@", ...side(edit.old_string, "-"), ...side(edit.new_string, "+")].join("\n")).join("\n")}
+`;
+}
+var TODO_MARK = { completed: "[x]", in_progress: "[~]", pending: "[ ]" };
+function claudeToolDetail(name, rawInput, result) {
+  if (name === "Bash") return void 0;
+  const input = record(rawInput) ?? {};
+  const ok = result && !result.error;
+  const text = ok ? result.text : void 0;
+  const out = ok ? record(result.structured) : void 0;
+  const unknown = () => ({ type: "unknown", input: rawInput ?? null, output: result?.text ?? null });
+  const filePath = pathOf(input);
+  switch (name) {
+    case "Read": {
+      if (!filePath) return unknown();
+      const file = out?.type === "text" ? record(out.file) : void 0;
+      const stripped = file ? void 0 : text !== void 0 ? stripReadGutter(text) : void 0;
+      const content = typeof file?.content === "string" ? file.content : stripped?.content ?? text;
+      return typed({ type: "read", filePath, content, offset: int(file?.startLine) ?? stripped?.startLine ?? int(input.offset), limit: int(input.limit) });
+    }
+    case "Write":
+      if (!filePath) return unknown();
+      return typed({ type: "write", filePath, content: typeof input.content === "string" ? input.content : void 0 });
+    case "Edit":
+      if (!filePath) return unknown();
+      return typed({ type: "edit", filePath, oldString: typeof input.old_string === "string" ? input.old_string : void 0, newString: typeof input.new_string === "string" ? input.new_string : void 0, unifiedDiff: structuredPatch(out?.structuredPatch) });
+    case "MultiEdit": {
+      if (!filePath) return unknown();
+      const edits = Array.isArray(input.edits) ? input.edits.filter(record) : [];
+      if (edits.length === 1) return typed({ type: "edit", filePath, oldString: str(edits[0].old_string) ?? void 0, newString: typeof edits[0].new_string === "string" ? edits[0].new_string : void 0, unifiedDiff: structuredPatch(out?.structuredPatch) });
+      return typed({ type: "edit", filePath, unifiedDiff: structuredPatch(out?.structuredPatch) ?? (edits.length ? replacementsDiff(edits) : void 0) });
+    }
+    case "NotebookEdit":
+      if (!filePath) return unknown();
+      return typed({ type: "edit", filePath, oldString: typeof out?.old_source === "string" ? out.old_source : void 0, newString: input.edit_mode === "delete" ? void 0 : typeof input.new_source === "string" ? input.new_source : void 0 });
+    case "Grep": {
+      const query = str(input.pattern);
+      if (!query) return unknown();
+      const structured = out && Array.isArray(out.filenames);
+      return typed({
+        type: "search",
+        query,
+        toolName: "grep",
+        content: structured ? typeof out.content === "string" ? out.content : void 0 : text,
+        filePaths: structured && out.filenames.length ? out.filenames.map(String) : void 0,
+        numFiles: structured ? int(out.numFiles) : void 0,
+        numMatches: structured ? int(out.numMatches) : void 0
+      });
+    }
+    case "Glob": {
+      const query = str(input.pattern);
+      if (!query) return unknown();
+      const structured = out && Array.isArray(out.filenames);
+      return typed({
+        type: "search",
+        query,
+        toolName: "glob",
+        content: structured ? void 0 : text,
+        filePaths: structured && out.filenames.length ? out.filenames.map(String) : void 0,
+        numFiles: structured ? int(out.numFiles) : void 0,
+        truncated: structured && typeof out.truncated === "boolean" ? out.truncated : void 0
+      });
+    }
+    case "WebFetch": {
+      const url = str(input.url) ?? str(out?.url);
+      if (!url) return unknown();
+      return typed({ type: "fetch", url, prompt: str(input.prompt), result: typeof out?.result === "string" ? out.result : text, code: int(out?.code) });
+    }
+    case "WebSearch": {
+      const query = str(input.query) ?? str(out?.query);
+      if (!query) return unknown();
+      const entries = Array.isArray(out?.results) ? out.results : [];
+      const webResults = entries.flatMap((entry) => Array.isArray(record(entry)?.content) ? entry.content : []).filter((hit) => typeof hit?.title === "string" && typeof hit?.url === "string").map((hit) => ({ title: hit.title, url: hit.url }));
+      const notes = entries.filter((entry) => typeof entry === "string");
+      return typed({ type: "search", query, toolName: "web_search", webResults: webResults.length ? webResults : void 0, content: out ? notes.length ? notes.join("\n") : void 0 : text });
+    }
+    case "Task":
+    case "Agent": {
+      const report = out && Array.isArray(out.content) ? resultText(out.content) : text;
+      return typed({ type: "sub_agent", subAgentType: str(input.subagent_type), description: str(input.description) ?? str(input.prompt), log: report });
+    }
+    case "ExitPlanMode":
+      return str(input.plan) ? typed({ type: "plan", text: input.plan }) : unknown();
+    case "Skill":
+      return str(input.skill) ? typed({ type: "plain_text", label: input.skill, text }) : unknown();
+    case "TodoWrite": {
+      const todos = Array.isArray(input.todos) ? input.todos.filter(record) : [];
+      if (!todos.length) return unknown();
+      return typed({ type: "plain_text", label: "Todos", text: todos.map((todo) => `${TODO_MARK[todo.status] ?? "[ ]"} ${String(todo.content ?? todo.activeForm ?? "")}`).join("\n") });
+    }
+    default:
+      return unknown();
+  }
+}
+function acpText(content) {
+  const parts = (Array.isArray(content) ? content : []).map((part) => part?.type === "content" && part.content?.type === "text" ? part.content.text : "").filter(Boolean);
+  return parts.length ? parts.join("\n") : void 0;
+}
+function acpToolDetail(call) {
+  const kind = call.kind ?? "other";
+  if (kind === "execute") return void 0;
+  const input = record(call.rawInput);
+  const output = record(call.rawOutput);
+  const locations = (Array.isArray(call.locations) ? call.locations : []).map(record).filter((entry) => Boolean(str(entry?.path)));
+  const diffs = (Array.isArray(call.content) ? call.content : []).map(record).filter((part) => part?.type === "diff" && Boolean(str(part.path)));
+  const text = acpText(call.content) ?? (typeof call.rawOutput === "string" ? call.rawOutput : str(output?.output) ?? str(output?.content));
+  const title = str(call.title);
+  const filePath = locations[0]?.path ?? pathOf(input);
+  const unknown = () => ({ type: "unknown", input: call.rawInput ?? null, output: call.rawOutput ?? text ?? null });
+  switch (kind) {
+    case "read":
+      if (!filePath) return unknown();
+      return typed({ type: "read", filePath, content: text, offset: int(input?.offset) ?? int(input?.line) ?? int(locations[0]?.line), limit: int(input?.limit) });
+    case "edit":
+    case "delete": {
+      const diff = diffs[0];
+      if (diff) {
+        const oldText = typeof diff.oldText === "string" ? diff.oldText : void 0;
+        const newText = typeof diff.newText === "string" ? diff.newText : void 0;
+        if (oldText === void 0 && newText !== void 0 && kind === "edit") return typed({ type: "write", filePath: diff.path, content: newText });
+        return typed({ type: "edit", filePath: diff.path, oldString: oldText, newString: kind === "delete" ? void 0 : newText });
+      }
+      if (!filePath) return unknown();
+      const oldString = str(input?.old_string) ?? str(input?.oldText) ?? str(input?.old_str);
+      const newString = str(input?.new_string) ?? str(input?.newText) ?? str(input?.new_str);
+      const unifiedDiff = str(input?.diff) ?? str(input?.patch) ?? str(input?.unified_diff);
+      if (kind === "edit" && !oldString && !unifiedDiff && typeof input?.content === "string") return typed({ type: "write", filePath, content: input.content });
+      return typed({ type: "edit", filePath, oldString, newString, unifiedDiff });
+    }
+    case "move": {
+      const from = filePath ?? str(input?.from) ?? str(input?.source);
+      const to = locations[1]?.path ?? str(input?.to) ?? str(input?.destination) ?? str(input?.new_path);
+      if (!from) return unknown();
+      return typed({ type: "plain_text", label: title ?? "Move", text: to ? `${from} \u2192 ${to}` : from });
+    }
+    case "search": {
+      const query = str(input?.query) ?? str(input?.pattern) ?? str(input?.q) ?? title;
+      if (!query) return unknown();
+      const paths = locations.map((entry) => entry.path);
+      return typed({ type: "search", query, toolName: "search", content: text, filePaths: paths.length ? paths : void 0 });
+    }
+    case "fetch": {
+      const url = str(input?.url);
+      if (url) return typed({ type: "fetch", url, prompt: str(input?.prompt), result: text });
+      const query = str(input?.query) ?? str(input?.q);
+      if (query) return typed({ type: "search", query, toolName: "web_search", content: text });
+      return unknown();
+    }
+    case "think":
+      return typed({ type: "plain_text", label: title ?? "Thinking", text: text ?? str(input?.thought) ?? str(input?.text) });
+    default:
+      return unknown();
+  }
+}
+function antigravityToolDetail(info) {
+  const tool = record(info);
+  const parameters = record(tool?.parameters) ?? {};
+  const output = typeof tool?.output === "string" && tool.output ? tool.output : void 0;
+  const filePath = str(parameters.AbsolutePath) ?? str(parameters.TargetFile);
+  switch (tool?.name) {
+    case "run_command":
+      if (typeof parameters.CommandLine === "string") return { type: "shell", command: parameters.CommandLine, ...str(parameters.Cwd) ? { cwd: parameters.Cwd } : {}, output: output ?? "" };
+      break;
+    case "view_file":
+      if (filePath) return typed({ type: "read", filePath, content: output, offset: int(parameters.StartLine), limit: int(parameters.EndLine) !== void 0 && int(parameters.StartLine) !== void 0 ? parameters.EndLine - parameters.StartLine + 1 : void 0 });
+      break;
+    case "write_to_file":
+      if (filePath) return typed({ type: "write", filePath, content: typeof parameters.CodeContent === "string" ? parameters.CodeContent : void 0 });
+      break;
+    case "replace_file_content":
+    case "multi_replace_file_content":
+      if (filePath) return typed({ type: "edit", filePath, oldString: typeof parameters.TargetContent === "string" ? parameters.TargetContent : void 0, newString: typeof parameters.ReplacementContent === "string" ? parameters.ReplacementContent : void 0 });
+      break;
+  }
+  return { type: "unknown", input: tool?.parameters ?? null, output: tool?.error?.message ?? output ?? null };
+}
+function withHeaders(path, diff) {
+  if (/^(--- |diff --git )/.test(diff)) return diff;
+  if (diff.startsWith("+++ ")) return `--- a/${path}
+${diff}`;
+  return `--- a/${path}
++++ b/${path}
+${diff}`;
+}
+var looksLikeDiff = (text) => /^(@@ |--- |\+\+\+ |diff --git )/.test(text);
+function changeDiff(kind, diff) {
+  if (kind !== "add" && kind !== "delete" || !diff || looksLikeDiff(diff)) return diff;
+  const lines = diff.replace(/\r\n?/g, "\n").replace(/\n$/, "").split("\n");
+  const n = lines.length;
+  return kind === "add" ? `@@ -0,0 +1,${n} @@
+${lines.map((line) => `+${line}`).join("\n")}
+` : `@@ -1,${n} +0,0 @@
+${lines.map((line) => `-${line}`).join("\n")}
+`;
+}
+function codexToolCall(item, done) {
+  const raw = String(item?.status ?? "");
+  const status = raw === "inProgress" || !raw && !done ? "running" : raw === "failed" || raw === "declined" ? "failed" : "completed";
+  const failed = (error) => status === "failed" ? { error: toolError(error) } : {};
+  if (item?.type === "fileChange") {
+    const changes = (Array.isArray(item.changes) ? item.changes : []).filter((change) => str(change?.path));
+    if (!changes.length) return { name: "apply_patch", status, detail: { type: "unknown", input: item.changes ?? null, output: null }, ...failed() };
+    let detail;
+    if (changes.length === 1) {
+      const [change] = changes;
+      const diff = typeof change.diff === "string" ? change.diff : "";
+      const kind = change.kind?.type ?? change.kind;
+      detail = kind === "add" && !looksLikeDiff(diff) ? typed({ type: "write", filePath: change.path, content: diff || void 0 }) : typed({ type: "edit", filePath: change.path, unifiedDiff: changeDiff(kind, diff) || void 0 });
+    } else {
+      const diff = changes.map((change) => {
+        const text = typeof change.diff === "string" ? changeDiff(change.kind?.type ?? change.kind, change.diff) : "";
+        return text ? withHeaders(change.path, text.endsWith("\n") ? text : `${text}
+`) : `--- a/${change.path}
++++ b/${change.path}
+`;
+      }).join("");
+      detail = typed({ type: "edit", filePath: changes[0].path, unifiedDiff: diff });
+    }
+    return { name: "apply_patch", status, detail, ...failed() };
+  }
+  if (item?.type === "webSearch") {
+    const query = str(item.query) ?? str(item.action?.query) ?? (Array.isArray(item.action?.queries) ? str(item.action.queries[0]) : void 0) ?? "";
+    return { name: "web_search", status, detail: typed({ type: "search", query, toolName: "web_search" }), ...failed() };
+  }
+  if (item?.type === "mcpToolCall") {
+    return { name: `mcp__${String(item.server ?? "")}__${String(item.tool ?? "")}`, status, detail: { type: "unknown", input: item.arguments ?? null, output: item.result ?? null }, ...failed(item.error?.message) };
+  }
+  if (item?.type === "collabAgentToolCall") {
+    return { name: "Sub-agent", status, detail: typed({ type: "sub_agent", subAgentType: "Sub-agent", description: str(item.prompt) }), ...failed(item.error?.message) };
+  }
+  return void 0;
+}
+export {
+  DETAIL_FILE_PATHS,
+  DETAIL_TEXT_CHARS,
+  DETAIL_TYPES,
+  DETAIL_WEB_RESULTS,
+  ERROR_CHARS,
+  TOOL_FAILED,
+  acpText,
+  acpToolDetail,
+  antigravityToolDetail,
+  boundDetail,
+  claudeToolDetail,
+  clipText,
+  codexToolCall,
+  resultText,
+  stripReadGutter,
+  toolError
+};

package/dist/tool-results.d.ts

@@ -0,0 +1,12 @@
+export declare const errorData: (error: unknown) => {
+    code?: string | undefined;
+    message: string;
+};
+export declare const toolResult: (success: boolean, value: unknown) => {
+    success: boolean;
+    contentItems: {
+        type: string;
+        text: string;
+    }[];
+};
+export declare const plainObject: (value: unknown, keys: string[]) => value is Record<string, any>;

package/dist/tool-results.js

@@ -0,0 +1,25 @@
+// packages/runtime/src/tool-results.ts
+import { promptSafe } from "@anhlp/alp-core/promptsafe";
+import { scrubText } from "@anhlp/alp-core/log";
+var errorData = (error) => ({
+  // It reaches timelines, run logs and clients: a provider's complaint may quote a credential.
+  message: scrubText(error instanceof Error ? error.message : String(error)),
+  // A transport marks a request the provider may have received before it failed (ALPD §66).
+  ...error?.outcomeUnknown ? { code: "outcome_unknown" } : {}
+});
+var toolResult = (success, value) => ({
+  success,
+  contentItems: [
+    {
+      type: "inputText",
+      // Results carry what other agents wrote and commands printed.
+      text: promptSafe(JSON.stringify(value))
+    }
+  ]
+});
+var plainObject = (value, keys) => !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((key) => keys.includes(key));
+export {
+  errorData,
+  plainObject,
+  toolResult
+};