hoomanjs 1.18.0 → 1.18.1

package/src/acp/approvals.ts

@@ -1,146 +0,0 @@
-import type { AgentSideConnection } from "@agentclientprotocol/sdk";
-import { BeforeToolCallEvent, type HookCallback } from "@strands-agents/sdk";
-import {
-  INTERNAL_ALWAYS_ALLOWED,
-  allowToolForSession,
-  isToolSessionAllowed,
-} from "../core/state/tool-approvals.ts";
-import { inferToolKind, toolDisplayTitle } from "./utils/tool-kind.ts";
-import { toolCallLocationsFromInput } from "./utils/tool-locations.ts";
-
-export function createAcpToolApprovalHook(
-  connection: AgentSideConnection,
-  sessionId: string,
-  /** Tool calls already announced via model stream (`tool_call` pending). */
-  streamPrimedToolCallIds?: () => ReadonlySet<string>,
-): HookCallback<BeforeToolCallEvent> {
-  return async function onBeforeToolCall(event) {
-    const name = event.toolUse.name;
-    const title = toolDisplayTitle(name, event.tool);
-    const kind = inferToolKind(name);
-    const locations = toolCallLocationsFromInput(name, event.toolUse.input);
-
-    const primed =
-      streamPrimedToolCallIds?.().has(event.toolUse.toolUseId) ?? false;
-    if (primed) {
-      await connection.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: event.toolUse.toolUseId,
-          title,
-          kind,
-          status: "pending",
-          rawInput: event.toolUse.input,
-          ...(locations ? { locations } : {}),
-        },
-      });
-    } else {
-      await connection.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "tool_call",
-          toolCallId: event.toolUse.toolUseId,
-          title,
-          kind,
-          status: "pending",
-          rawInput: event.toolUse.input,
-          ...(locations ? { locations } : {}),
-        },
-      });
-    }
-
-    if (
-      INTERNAL_ALWAYS_ALLOWED.has(name) ||
-      isToolSessionAllowed(event.agent, name)
-    ) {
-      await connection.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: event.toolUse.toolUseId,
-          status: "in_progress",
-        },
-      });
-      return;
-    }
-
-    const response = await connection.requestPermission({
-      sessionId,
-      toolCall: {
-        toolCallId: event.toolUse.toolUseId,
-        title,
-        kind,
-        status: "pending",
-        rawInput: event.toolUse.input,
-        ...(locations ? { locations } : {}),
-      },
-      options: [
-        {
-          kind: "allow_once",
-          name: "Allow once",
-          optionId: "allow_once",
-        },
-        {
-          kind: "allow_always",
-          name: "Always allow",
-          optionId: "allow_always",
-        },
-        {
-          kind: "reject_once",
-          name: "Reject",
-          optionId: "reject_once",
-        },
-      ],
-    });
-
-    if (response.outcome.outcome === "cancelled") {
-      event.cancel = `Tool "${name}" permission request was cancelled.`;
-      await connection.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: event.toolUse.toolUseId,
-          status: "failed",
-          rawOutput: { reason: "permission_cancelled" },
-        },
-      });
-      return;
-    }
-
-    const optionId = response.outcome.optionId;
-    if (optionId === "allow_once") {
-      await connection.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: event.toolUse.toolUseId,
-          status: "in_progress",
-        },
-      });
-      return;
-    }
-    if (optionId === "allow_always") {
-      allowToolForSession(event.agent, name);
-      await connection.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: event.toolUse.toolUseId,
-          status: "in_progress",
-        },
-      });
-      return;
-    }
-    event.cancel = `Tool "${name}" was rejected by the user.`;
-    await connection.sessionUpdate({
-      sessionId,
-      update: {
-        sessionUpdate: "tool_call_update",
-        toolCallId: event.toolUse.toolUseId,
-        status: "failed",
-        rawOutput: { reason: "permission_rejected" },
-      },
-    });
-  };
-}

package/src/acp/index.ts

@@ -1 +0,0 @@
-export { AcpAgent, runAcpStdio } from "./acp-agent.ts";

package/src/acp/mcp-servers.ts

@@ -1,64 +0,0 @@
-import { RequestError, type McpServer } from "@agentclientprotocol/sdk";
-import type { NamedMcpTransport } from "../core/mcp/index.ts";
-
-function pairsToRecord(
-  pairs: ReadonlyArray<{ name: string; value: string }>,
-): Record<string, string> | undefined {
-  if (pairs.length === 0) {
-    return undefined;
-  }
-  return Object.fromEntries(pairs.map((pair) => [pair.name, pair.value]));
-}
-
-function toNamedTransport(server: McpServer): NamedMcpTransport {
-  if ("command" in server) {
-    return {
-      name: server.name,
-      transport: {
-        type: "stdio",
-        command: server.command,
-        args: server.args,
-        env: pairsToRecord(server.env),
-      },
-    };
-  }
-  if (server.type === "http") {
-    return {
-      name: server.name,
-      transport: {
-        type: "streamable-http",
-        url: server.url,
-        headers: pairsToRecord(server.headers),
-      },
-    };
-  }
-  return {
-    name: server.name,
-    transport: {
-      type: "sse",
-      url: server.url,
-      headers: pairsToRecord(server.headers),
-    },
-  };
-}
-
-/**
- * Convert ACP session MCP server definitions into the transport shape used by
- * Hooman's MCP manager.
- */
-export function normalizeAcpSessionMcpServers(
-  servers: readonly McpServer[] | null | undefined,
-): NamedMcpTransport[] {
-  const normalized = (servers ?? []).map(toNamedTransport);
-  const seen = new Set<string>();
-  for (const { name } of normalized) {
-    if (seen.has(name)) {
-      throw RequestError.invalidParams({
-        mcpServers: servers,
-        message: `Duplicate ACP MCP server name "${name}" in session request`,
-      });
-    }
-    seen.add(name);
-  }
-  return normalized;
-}

package/src/acp/meta/system-prompt.ts

@@ -1,44 +0,0 @@
-const MAX_SYSTEM_PROMPT_LEN = 32_000;
-
-function sanitizeClientSystemPrompt(raw: string): string {
-  return raw.replace(/\r\n?/g, "\n").trim().slice(0, MAX_SYSTEM_PROMPT_LEN);
-}
-
-/**
- * Session-level system prompt override from ACP `_meta` on `session/new` and `session/load`.
- *
- * Resolution order (first non-empty wins):
- * - `_meta["hooman/systemPrompt"]` (string)
- * - `_meta.hooman.systemPrompt` (string)
- * - `_meta.systemPrompt` (string)
- *
- * Values are normalized to `\n`, trimmed, and capped in length.
- * Empty after sanitization is treated as absent.
- */
-export function extractAcpClientSystemPrompt(
-  _meta: unknown,
-): string | undefined {
-  if (!_meta || typeof _meta !== "object") {
-    return undefined;
-  }
-  const m = _meta as Record<string, unknown>;
-  const candidates: unknown[] = [
-    m["hooman/systemPrompt"],
-    m.hooman !== null &&
-    typeof m.hooman === "object" &&
-    "systemPrompt" in m.hooman
-      ? (m.hooman as Record<string, unknown>).systemPrompt
-      : undefined,
-    m.systemPrompt,
-  ];
-  for (const c of candidates) {
-    if (typeof c !== "string") {
-      continue;
-    }
-    const s = sanitizeClientSystemPrompt(c);
-    if (s) {
-      return s;
-    }
-  }
-  return undefined;
-}

package/src/acp/meta/user-id.ts

@@ -1,44 +0,0 @@
-const MAX_USER_ID_LEN = 256;
-
-function sanitizeClientUserId(raw: string): string {
-  const t = raw.trim().slice(0, MAX_USER_ID_LEN);
-  if (!t) {
-    return "";
-  }
-  return t.replace(/[\u0000-\u001F\u007F]/g, "");
-}
-
-/**
- * Logical user id from ACP `_meta` on `session/new` and `session/load`.
- *
- * Resolution order (first non-empty wins):
- * - `_meta["hooman/userId"]` (string)
- * - `_meta.hooman.userId` (string)
- * - `_meta.userId` (string)
- *
- * Values are trimmed, capped in length, and stripped of ASCII control characters.
- * Empty after sanitization is treated as absent.
- */
-export function extractAcpClientUserId(_meta: unknown): string | undefined {
-  if (!_meta || typeof _meta !== "object") {
-    return undefined;
-  }
-  const m = _meta as Record<string, unknown>;
-  const candidates: unknown[] = [
-    m["hooman/userId"],
-    m.hooman !== null && typeof m.hooman === "object" && "userId" in m.hooman
-      ? (m.hooman as Record<string, unknown>).userId
-      : undefined,
-    m.userId,
-  ];
-  for (const c of candidates) {
-    if (typeof c !== "string") {
-      continue;
-    }
-    const s = sanitizeClientUserId(c);
-    if (s) {
-      return s;
-    }
-  }
-  return undefined;
-}

package/src/acp/prompt-invoke.ts

@@ -1,149 +0,0 @@
-import type { ContentBlock as AcpContentBlock } from "@agentclientprotocol/sdk";
-import {
-  Agent as StrandsAgent,
-  DocumentBlock,
-  ImageBlock,
-  Message,
-  TextBlock,
-} from "@strands-agents/sdk";
-import type { ContentBlock } from "@strands-agents/sdk";
-
-type AgentStreamInput = Parameters<
-  InstanceType<typeof StrandsAgent>["stream"]
->[0];
-
-function decodeBase64(data: string): Uint8Array {
-  return new Uint8Array(Buffer.from(data, "base64"));
-}
-
-function mimeToImageFormat(mime: string): "png" | "jpeg" | "gif" | "webp" {
-  const m = mime.toLowerCase();
-  if (m.includes("png")) return "png";
-  if (m.includes("jpeg") || m.includes("jpg")) return "jpeg";
-  if (m.includes("gif")) return "gif";
-  if (m.includes("webp")) return "webp";
-  return "png";
-}
-
-function mimeToDocFormat(
-  mime: string,
-): "pdf" | "html" | "txt" | "md" | "json" | "xml" | "csv" {
-  const m = mime.toLowerCase();
-  if (m.includes("pdf")) return "pdf";
-  if (m.includes("html")) return "html";
-  if (m.includes("markdown") || m.endsWith("/md")) return "md";
-  if (m.includes("json")) return "json";
-  if (m.includes("xml")) return "xml";
-  if (m.includes("csv")) return "csv";
-  return "txt";
-}
-
-function acpBlockToStrands(block: AcpContentBlock): ContentBlock[] {
-  switch (block.type) {
-    case "text":
-      return [new TextBlock(block.text)];
-    case "resource_link":
-      return [
-        new TextBlock(
-          `[resource_link name=${JSON.stringify(block.name)} uri=${JSON.stringify(block.uri)}]`,
-        ),
-      ];
-    case "resource": {
-      const r = block.resource;
-      if ("text" in r) {
-        return [new TextBlock(r.text)];
-      }
-      const bytes = decodeBase64(r.blob);
-      const mime = (r.mimeType ?? "application/octet-stream").toLowerCase();
-      if (mime.startsWith("image/")) {
-        return [
-          new ImageBlock({
-            format: mimeToImageFormat(mime),
-            source: { bytes },
-          }),
-        ];
-      }
-      return [
-        new DocumentBlock({
-          format: mimeToDocFormat(mime),
-          name: r.uri.split("/").pop() ?? "attachment",
-          source: { bytes },
-        }),
-      ];
-    }
-    case "image": {
-      const bytes = decodeBase64(block.data);
-      return [
-        new ImageBlock({
-          format: mimeToImageFormat(block.mimeType),
-          source: { bytes },
-        }),
-      ];
-    }
-    case "audio": {
-      const bytes = decodeBase64(block.data);
-      return [
-        new TextBlock(
-          `[audio mimeType=${JSON.stringify(block.mimeType)} bytes=${bytes.byteLength}]`,
-        ),
-        new DocumentBlock({
-          format: "txt",
-          name: "audio.bin",
-          source: { bytes },
-        }),
-      ];
-    }
-    default:
-      return [
-        new TextBlock(
-          `[unsupported ACP block ${JSON.stringify(block as unknown)}]`,
-        ),
-      ];
-  }
-}
-
-/**
- * Convert an ACP `session/prompt` payload to Strands {@link InvokeArgs} (multimodal user turn).
- */
-export function acpPromptToInvokeArgs(
-  prompt: AcpContentBlock[],
-): AgentStreamInput {
-  const parts: ContentBlock[] = [];
-  for (const block of prompt) {
-    parts.push(...acpBlockToStrands(block));
-  }
-  return [new Message({ role: "user", content: parts })];
-}
-
-/** Flattened text for `user_message_chunk` echoes (lossy but readable). */
-export function acpPromptEchoText(prompt: AcpContentBlock[]): string {
-  const lines: string[] = [];
-  for (const block of prompt) {
-    switch (block.type) {
-      case "text":
-        lines.push(block.text);
-        break;
-      case "resource_link":
-        lines.push(`[resource_link ${block.name}](${block.uri})`);
-        break;
-      case "resource":
-        if ("text" in block.resource) {
-          lines.push(block.resource.text);
-        } else {
-          lines.push(
-            `[binary resource uri=${block.resource.uri} mime=${block.resource.mimeType ?? ""} len=${block.resource.blob.length}]`,
-          );
-        }
-        break;
-      case "image":
-        lines.push(`[image ${block.mimeType} ${block.data.length} b64 chars]`);
-        break;
-      case "audio":
-        lines.push(`[audio ${block.mimeType} ${block.data.length} b64 chars]`);
-        break;
-      default:
-        lines.push(JSON.stringify(block));
-    }
-  }
-  return lines.join("\n\n").trim();
-}

package/src/acp/sessions/config-options.ts

@@ -1,120 +0,0 @@
-import { RequestError } from "@agentclientprotocol/sdk";
-import type {
-  SessionConfigOption,
-  SetSessionConfigOptionRequest,
-} from "@agentclientprotocol/sdk";
-import type { Config } from "../../core/config.ts";
-
-export const HOOMAN_LTM_CONFIG_ID = "hooman.longTermMemory" as const;
-export const HOOMAN_WIKI_CONFIG_ID = "hooman.wiki" as const;
-export const HOOMAN_TODO_CONFIG_ID = "hooman.todo" as const;
-
-export function buildSessionConfigOptions(
-  config: Config,
-): SessionConfigOption[] {
-  return [
-    {
-      type: "select",
-      id: HOOMAN_TODO_CONFIG_ID,
-      name: "Todo tracking",
-      description:
-        "When enabled, the agent can use update_todos to track multi-step progress in app state.",
-      category: "_hooman",
-      currentValue: config.tools.todo.enabled ? "on" : "off",
-      options: [
-        { value: "on", name: "On" },
-        { value: "off", name: "Off" },
-      ],
-    },
-    {
-      type: "select",
-      id: HOOMAN_LTM_CONFIG_ID,
-      name: "Long-term memory",
-      description:
-        "When enabled, the agent can store and search memories (requires Chroma at the configured URL).",
-      category: "_hooman",
-      currentValue: config.ltm.enabled ? "on" : "off",
-      options: [
-        { value: "on", name: "On" },
-        { value: "off", name: "Off" },
-      ],
-    },
-    {
-      type: "select",
-      id: HOOMAN_WIKI_CONFIG_ID,
-      name: "Wiki",
-      description:
-        "When enabled, the agent can read, write, and search wiki pages (requires Chroma at the configured URL).",
-      category: "_hooman",
-      currentValue: config.wiki.enabled ? "on" : "off",
-      options: [
-        { value: "on", name: "On" },
-        { value: "off", name: "Off" },
-      ],
-    },
-  ];
-}
-
-export function applySessionConfigOption(
-  config: Config,
-  params: SetSessionConfigOptionRequest,
-): void {
-  if ("type" in params && params.type === "boolean") {
-    throw RequestError.invalidParams({
-      message: "Boolean session config options are not supported.",
-    });
-  }
-  if (
-    params.configId !== HOOMAN_TODO_CONFIG_ID &&
-    params.configId !== HOOMAN_LTM_CONFIG_ID &&
-    params.configId !== HOOMAN_WIKI_CONFIG_ID
-  ) {
-    throw RequestError.invalidParams({ configId: params.configId });
-  }
-  const value = params.value;
-  if (value !== "on" && value !== "off") {
-    throw RequestError.invalidParams({ value });
-  }
-  if (params.configId === HOOMAN_LTM_CONFIG_ID) {
-    const chroma = config.ltm.chroma;
-    config.update({
-      tools: {
-        ...config.tools,
-        ltm: {
-          enabled: value === "on",
-          chroma: {
-            url: chroma.url,
-            collection: { memory: chroma.collection.memory },
-          },
-        },
-      },
-    });
-    return;
-  }
-
-  if (params.configId === HOOMAN_TODO_CONFIG_ID) {
-    config.update({
-      tools: {
-        ...config.tools,
-        todo: {
-          enabled: value === "on",
-        },
-      },
-    });
-    return;
-  }
-
-  const chroma = config.wiki.chroma;
-  config.update({
-    tools: {
-      ...config.tools,
-      wiki: {
-        enabled: value === "on",
-        chroma: {
-          url: chroma.url,
-          collection: { wiki: chroma.collection.wiki },
-        },
-      },
-    },
-  });
-}

package/src/acp/sessions/replay.ts

@@ -1,131 +0,0 @@
-import type { AgentSideConnection } from "@agentclientprotocol/sdk";
-import type { Message } from "@strands-agents/sdk";
-import {
-  ToolResultBlock,
-  ToolUseBlock,
-  type ContentBlock,
-} from "@strands-agents/sdk";
-import { inferToolKind } from "../utils/tool-kind.ts";
-import { toolResultToAcpContent } from "../utils/tool-result-content.ts";
-
-function blockToFallbackText(block: ContentBlock): string | null {
-  if (block.type === "textBlock") {
-    return block.text;
-  }
-  try {
-    return JSON.stringify(block.toJSON?.() ?? block, null, 2);
-  } catch {
-    return String(block);
-  }
-}
-
-function collectToolResults(messages: Message[]): Map<string, ToolResultBlock> {
-  const byId = new Map<string, ToolResultBlock>();
-  for (const message of messages) {
-    for (const block of message.content) {
-      if (block instanceof ToolResultBlock) {
-        byId.set(block.toolUseId, block);
-      }
-    }
-  }
-  return byId;
-}
-
-/**
- * Replay persisted conversation to the client using ACP session updates.
- * Emits separate chunks for text vs structured tool call / result updates.
- */
-export async function replayConversationHistory(
-  connection: AgentSideConnection,
-  sessionId: string,
-  messages: Message[],
-): Promise<void> {
-  const resultsByToolUseId = collectToolResults(messages);
-
-  for (const message of messages) {
-    const role = message.role;
-
-    for (const block of message.content) {
-      if (role === "user") {
-        if (block instanceof ToolResultBlock) {
-          await connection.sessionUpdate({
-            sessionId,
-            update: {
-              sessionUpdate: "tool_call_update",
-              toolCallId: block.toolUseId,
-              status: block.status === "success" ? "completed" : "failed",
-              rawOutput: block.toJSON() as unknown,
-              content: toolResultToAcpContent(block),
-            },
-          });
-          continue;
-        }
-        const text = blockToFallbackText(block);
-        if (text?.trim()) {
-          await connection.sessionUpdate({
-            sessionId,
-            update: {
-              sessionUpdate: "user_message_chunk",
-              content: { type: "text", text },
-            },
-          });
-        }
-        continue;
-      }
-
-      if (role === "assistant") {
-        if (block instanceof ToolUseBlock) {
-          const hasResult = resultsByToolUseId.has(block.toolUseId);
-          await connection.sessionUpdate({
-            sessionId,
-            update: {
-              sessionUpdate: "tool_call",
-              toolCallId: block.toolUseId,
-              title: block.name,
-              kind: inferToolKind(block.name),
-              rawInput: block.input,
-              status: hasResult ? "in_progress" : "completed",
-            },
-          });
-          continue;
-        }
-        if (block.type === "textBlock") {
-          const t = block.text;
-          if (t) {
-            await connection.sessionUpdate({
-              sessionId,
-              update: {
-                sessionUpdate: "agent_message_chunk",
-                content: { type: "text", text: t },
-              },
-            });
-          }
-          continue;
-        }
-        if (block.type === "reasoningBlock") {
-          const t = blockToFallbackText(block);
-          if (t?.trim()) {
-            await connection.sessionUpdate({
-              sessionId,
-              update: {
-                sessionUpdate: "agent_thought_chunk",
-                content: { type: "text", text: t },
-              },
-            });
-          }
-          continue;
-        }
-        const fallback = blockToFallbackText(block);
-        if (fallback?.trim()) {
-          await connection.sessionUpdate({
-            sessionId,
-            update: {
-              sessionUpdate: "agent_message_chunk",
-              content: { type: "text", text: fallback },
-            },
-          });
-        }
-      }
-    }
-  }
-}