@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/ipc/skill-routes/__tests__/registries.test.ts

@@ -1,400 +0,0 @@
-/**
- * Handler-level tests for the host.registries.* IPC routes.
- *
- * Each test invokes the route handler directly rather than going through
- * the socket round-trip so assertions can observe the in-process registry
- * side-effects (proxy tools in the tool registry, skill routes in the HTTP
- * registry, shutdown hooks in the shutdown registry). Socket-level
- * integration is covered by `ipc/__tests__/skill-server.test.ts`.
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { runShutdownHooks } from "../../../daemon/shutdown-registry.js";
-import {
-  matchSkillRoute,
-  resetSkillRoutesForTests,
-} from "../../../runtime/skill-route-registry.js";
-import {
-  __clearExternalToolProvidersForTesting,
-  __clearRegistryForTesting,
-  getTool,
-  getToolOwner,
-} from "../../../tools/registry.js";
-import { RiskLevel } from "../../../tools/types.js";
-import {
-  __getActiveSessionCountForTesting,
-  __resetActiveSessionsForTesting,
-  registerShutdownHookRoute,
-  registerSkillRouteRoute,
-  registerToolsRoute,
-  reportSessionEndedRoute,
-  reportSessionStartedRoute,
-  setMeetHostSupervisorForSessionReports,
-} from "../registries.js";
-
-// ---------------------------------------------------------------------------
-// Shared setup
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  __clearRegistryForTesting();
-  __clearExternalToolProvidersForTesting();
-  resetSkillRoutesForTests();
-  __resetActiveSessionsForTesting();
-});
-
-afterEach(() => {
-  __clearRegistryForTesting();
-  __clearExternalToolProvidersForTesting();
-  resetSkillRoutesForTests();
-  __resetActiveSessionsForTesting();
-});
-
-// ---------------------------------------------------------------------------
-// host.registries.register_tools
-// ---------------------------------------------------------------------------
-
-describe("host.registries.register_tools", () => {
-  test("installs proxy tools into the daemon's external tool registry", async () => {
-    // `skillId` lives at the top of the params object (one frame = one
-    // skill's batch). The per-tool manifest schema no longer carries an
-    // `owner` field — ownership flows in through this top-level key and
-    // is recorded in the registry's `ownersByName` map.
-    const result = (await registerToolsRoute.handler({
-      skillId: "demo-skill",
-      tools: [
-        {
-          name: "skill_demo_tool",
-          description: "demo tool",
-          input_schema: { type: "object", properties: {} },
-          defaultRiskLevel: "low",
-          category: "skill",
-          executionTarget: "sandbox",
-        },
-      ],
-    })) as { registered: string[] };
-
-    expect(result.registered).toEqual(["skill_demo_tool"]);
-    const installed = getTool("skill_demo_tool");
-    expect(installed).toBeDefined();
-    // Ownership lives on the registry — getToolOwner is the single source of
-    // truth. The Tool object itself no longer carries the kind.
-    expect(getToolOwner("skill_demo_tool")).toEqual({
-      kind: "skill",
-      id: "demo-skill",
-    });
-  });
-
-  test("proxy execute surfaces an error result when no supervisor is attached", async () => {
-    await registerToolsRoute.handler({
-      skillId: "stub-skill",
-      tools: [
-        {
-          name: "skill_stub_tool",
-          description: "stub",
-          input_schema: { type: "object" },
-          defaultRiskLevel: "medium",
-          category: "skill",
-        },
-      ],
-    });
-
-    const installed = getTool("skill_stub_tool");
-    expect(installed).toBeDefined();
-    // Skill tools arrive without an `execute` closure (closures don't cross
-    // IPC). `finalizeTool` synthesizes a no-op error result so unsupervised
-    // invocations surface a clear "not wired up" signal to the model.
-    const result = await installed!.execute(
-      {},
-      {
-        workingDir: "/tmp",
-        conversationId: "c",
-        trustClass: "guardian",
-      },
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content).toMatch(/no execute implementation/i);
-  });
-
-  test("rejects empty tool list", async () => {
-    await expect(
-      registerToolsRoute.handler({ skillId: "any-skill", tools: [] }),
-    ).rejects.toThrow();
-  });
-
-  test("fills defaults for partial tool entries", async () => {
-    // Wire and author share one schema (`ToolDefinitionSchema`, all-optional)
-    // and the daemon runs `finalizeTool` on every incoming tool. So a
-    // partial entry doesn't reject — defaults fill in for missing fields.
-    const result = (await registerToolsRoute.handler({
-      skillId: "partial-skill",
-      tools: [{ name: "partial_tool" }],
-    })) as { registered: string[] };
-    expect(result.registered).toEqual(["partial_tool"]);
-    const installed = getTool("partial_tool");
-    expect(installed).toBeDefined();
-    expect(installed!.defaultRiskLevel).toBe(RiskLevel.Medium);
-    expect(installed!.executionTarget).toBe("sandbox");
-  });
-
-  test("rejects missing skillId", async () => {
-    // skillId is the only place ownership flows in over IPC — without it
-    // the registry can't claim the tools, so the handler must reject.
-    await expect(
-      registerToolsRoute.handler({
-        tools: [
-          {
-            name: "skill_orphan_tool",
-            description: "no owner",
-            input_schema: { type: "object" },
-            defaultRiskLevel: "low",
-            category: "skill",
-          },
-        ],
-      }),
-    ).rejects.toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// host.registries.register_skill_route
-// ---------------------------------------------------------------------------
-
-describe("host.registries.register_skill_route", () => {
-  test("installs a proxy route visible to matchSkillRoute", async () => {
-    const result = (await registerSkillRouteRoute.handler({
-      patternSource: "^/skill/demo$",
-      methods: ["GET", "POST"],
-    })) as { patternSource: string; methods: string[] };
-    expect(result.patternSource).toBe("^/skill/demo$");
-    expect(result.methods).toEqual(["GET", "POST"]);
-
-    const match = matchSkillRoute("/skill/demo", "POST");
-    expect(match).not.toBeNull();
-    expect(match?.kind).toBe("match");
-  });
-
-  test("proxy handler returns 501 until PR 28 dispatch lands", async () => {
-    await registerSkillRouteRoute.handler({
-      patternSource: "^/skill/stub$",
-      methods: ["GET"],
-    });
-
-    const match = matchSkillRoute("/skill/stub", "GET");
-    if (match?.kind !== "match") throw new Error("expected match");
-    const response = await match.route.handler(
-      new Request("http://localhost/skill/stub"),
-      match.match,
-    );
-    expect(response.status).toBe(501);
-  });
-
-  test("rejects malformed regex source", async () => {
-    await expect(
-      registerSkillRouteRoute.handler({
-        patternSource: "[unterminated",
-        methods: ["GET"],
-      }),
-    ).rejects.toThrow(/Invalid skill-route pattern/);
-  });
-
-  test("rejects empty methods list", async () => {
-    await expect(
-      registerSkillRouteRoute.handler({
-        patternSource: "^/x$",
-        methods: [],
-      }),
-    ).rejects.toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// host.registries.register_shutdown_hook
-// ---------------------------------------------------------------------------
-
-describe("host.registries.register_shutdown_hook", () => {
-  test("registers a hook that runs on runShutdownHooks", async () => {
-    // Register a sibling hook that records invocation so we can assert the
-    // runShutdownHooks walk reached our newly registered entry.
-    const { registerShutdownHook } =
-      await import("../../../daemon/shutdown-registry.js");
-    let sentinelRan = false;
-    registerShutdownHook("pr24-test-sentinel", async () => {
-      sentinelRan = true;
-    });
-
-    const result = (await registerShutdownHookRoute.handler({
-      name: "pr24-test-hook",
-    })) as { name: string };
-    expect(result.name).toBe("pr24-test-hook");
-
-    await runShutdownHooks("test-shutdown");
-    expect(sentinelRan).toBe(true);
-  });
-
-  test("rejects missing name", async () => {
-    await expect(
-      registerShutdownHookRoute.handler({ name: "" }),
-    ).rejects.toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// host.registries.report_session_started / report_session_ended
-// ---------------------------------------------------------------------------
-
-describe("host.registries.report_session_{started,ended}", () => {
-  test("started increments, ended decrements, duplicate-aware", async () => {
-    expect(__getActiveSessionCountForTesting()).toBe(0);
-
-    let result = (await reportSessionStartedRoute.handler({
-      meetingId: "meet-a",
-    })) as { activeCount: number };
-    expect(result.activeCount).toBe(1);
-
-    // Duplicate started for the same meeting should be idempotent.
-    result = (await reportSessionStartedRoute.handler({
-      meetingId: "meet-a",
-    })) as { activeCount: number };
-    expect(result.activeCount).toBe(1);
-
-    result = (await reportSessionStartedRoute.handler({
-      meetingId: "meet-b",
-    })) as { activeCount: number };
-    expect(result.activeCount).toBe(2);
-
-    result = (await reportSessionEndedRoute.handler({
-      meetingId: "meet-a",
-    })) as { activeCount: number };
-    expect(result.activeCount).toBe(1);
-
-    // Ending a never-started meeting is a no-op.
-    result = (await reportSessionEndedRoute.handler({
-      meetingId: "meet-unknown",
-    })) as { activeCount: number };
-    expect(result.activeCount).toBe(1);
-
-    result = (await reportSessionEndedRoute.handler({
-      meetingId: "meet-b",
-    })) as { activeCount: number };
-    expect(result.activeCount).toBe(0);
-  });
-
-  test("rejects missing meetingId", async () => {
-    await expect(
-      reportSessionStartedRoute.handler({ meetingId: "" }),
-    ).rejects.toThrow();
-    await expect(
-      reportSessionEndedRoute.handler({ meetingId: "" }),
-    ).rejects.toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Lazy-external short-circuit (PR D)
-//
-// When a `MeetHostSupervisor` is registered via
-// `setMeetHostSupervisorForSessionReports`, the manifest loader has
-// already installed proxy tools/routes/shutdown hooks. The IPC handlers
-// must NOT re-install duplicates — they should just pin the incoming
-// connection on the supervisor and return a sensible ack frame.
-// ---------------------------------------------------------------------------
-
-describe("lazy-external short-circuit", () => {
-  type CapturedConnection = {
-    connectionId: string;
-    addRouteHandle: () => void;
-    addSkillToolsOwner: () => void;
-  };
-
-  function makeFakeConnection(id = "conn-test"): CapturedConnection {
-    return {
-      connectionId: id,
-      addRouteHandle: () => undefined,
-      addSkillToolsOwner: () => undefined,
-    };
-  }
-
-  function makeStubSupervisor(): {
-    supervisor: Parameters<typeof setMeetHostSupervisorForSessionReports>[0];
-    setActiveCalls: CapturedConnection[];
-  } {
-    const setActiveCalls: CapturedConnection[] = [];
-    const supervisor = {
-      reportSessionStarted: () => undefined,
-      reportSessionEnded: () => undefined,
-      activeSessionCount: 0,
-      setActiveConnection: (conn: CapturedConnection) => {
-        setActiveCalls.push(conn);
-      },
-    } as unknown as Parameters<
-      typeof setMeetHostSupervisorForSessionReports
-    >[0];
-    return { supervisor, setActiveCalls };
-  }
-
-  test("register_tools skips in-memory registration and pins connection", async () => {
-    const { supervisor, setActiveCalls } = makeStubSupervisor();
-    setMeetHostSupervisorForSessionReports(supervisor);
-    const conn = makeFakeConnection();
-
-    const result = (await registerToolsRoute.handler(
-      {
-        skillId: "demo-skill",
-        tools: [
-          {
-            name: "skill_demo_tool",
-            description: "demo",
-            input_schema: {},
-            defaultRiskLevel: "low",
-            category: "skill",
-          },
-        ],
-      },
-      conn,
-    )) as { registered: string[] };
-
-    expect(result.registered).toEqual(["skill_demo_tool"]);
-    expect(setActiveCalls).toHaveLength(1);
-    expect(setActiveCalls[0]?.connectionId).toBe(conn.connectionId);
-    // Tool should NOT have been installed into the in-memory registry —
-    // the manifest loader already owns that side.
-    expect(getTool("skill_demo_tool")).toBeUndefined();
-  });
-
-  test("register_skill_route skips in-memory registration and pins connection", async () => {
-    const { supervisor, setActiveCalls } = makeStubSupervisor();
-    setMeetHostSupervisorForSessionReports(supervisor);
-    const conn = makeFakeConnection("route-conn");
-
-    const result = (await registerSkillRouteRoute.handler(
-      {
-        patternSource: "^/skill/lazy$",
-        methods: ["GET"],
-      },
-      conn,
-    )) as { patternSource: string; methods: string[] };
-
-    expect(result.patternSource).toBe("^/skill/lazy$");
-    expect(setActiveCalls).toHaveLength(1);
-    expect(setActiveCalls[0]?.connectionId).toBe("route-conn");
-    // Route should NOT have been installed in the route registry.
-    expect(matchSkillRoute("/skill/lazy", "GET")).toBeNull();
-  });
-
-  test("register_shutdown_hook skips registration and pins connection", async () => {
-    const { supervisor, setActiveCalls } = makeStubSupervisor();
-    setMeetHostSupervisorForSessionReports(supervisor);
-    const conn = makeFakeConnection("hook-conn");
-
-    const result = (await registerShutdownHookRoute.handler(
-      { name: "lazy-hook" },
-      conn,
-    )) as { name: string };
-
-    expect(result.name).toBe("lazy-hook");
-    expect(setActiveCalls).toHaveLength(1);
-    expect(setActiveCalls[0]?.connectionId).toBe("hook-conn");
-  });
-});

package/src/ipc/skill-routes/config.ts

@@ -1,47 +0,0 @@
-/**
- * Skill IPC routes: `host.config.getSection` and `host.config.isFeatureFlagEnabled`.
- *
- * Expose the daemon config and feature-flag resolver to out-of-process skills.
- * `getSection` returns a nested value looked up by dot-path (e.g. `"llm.default"`);
- * `isFeatureFlagEnabled` consults the standard assistant flag resolver so skills
- * observe the same overrides and remote values the in-process code does.
- */
-
-import { z } from "zod";
-
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig, getNestedValue } from "../../config/loader.js";
-import type { SkillIpcRoute } from "../skill-ipc-types.js";
-
-const GetSectionParams = z.object({
-  path: z.string().min(1),
-});
-
-const IsFeatureFlagEnabledParams = z.object({
-  key: z.string().min(1),
-});
-
-export const hostConfigGetSectionRoute: SkillIpcRoute = {
-  method: "host.config.getSection",
-  handler: (params) => {
-    const { path } = GetSectionParams.parse(params);
-    const value = getNestedValue(
-      getConfig() as unknown as Record<string, unknown>,
-      path,
-    );
-    return value ?? null;
-  },
-};
-
-export const hostConfigIsFeatureFlagEnabledRoute: SkillIpcRoute = {
-  method: "host.config.isFeatureFlagEnabled",
-  handler: (params) => {
-    const { key } = IsFeatureFlagEnabledParams.parse(params);
-    return isAssistantFeatureFlagEnabled(key, getConfig());
-  },
-};
-
-export const configRoutes: SkillIpcRoute[] = [
-  hostConfigGetSectionRoute,
-  hostConfigIsFeatureFlagEnabledRoute,
-];

package/src/ipc/skill-routes/events.ts

@@ -1,147 +0,0 @@
-/**
- * Skill IPC routes for `host.events.*`.
- *
- * Exposes the daemon's `assistantEventHub` to out-of-process skills so they
- * can publish, subscribe to, and construct `AssistantEvent` envelopes
- * without linking against `assistant/` directly. Mirrors the in-process
- * `EventsFacet` surface defined in `@vellumai/skill-host-contracts` and
- * implemented for in-process callers by `DaemonSkillHost`.
- *
- * ### Routes
- *
- * - `host.events.publish` — one-shot RPC. Params `{ event: AssistantEvent }`.
- *   Forwards to `assistantEventHub.publish(event)` and resolves once all
- *   matching subscribers have been dispatched.
- *
- * - `host.events.subscribe` — long-lived stream. Params
- *   `{ filter: AssistantEventFilter }`. The server opens a subscription on
- *   `assistantEventHub` and streams each matching event back as a delivery
- *   frame (`{ id, event: "delivery", payload }`) until the client
- *   disconnects or sends the `host.events.subscribe.close` control method.
- *   Teardown is wired through the IPC server's per-socket subscription map
- *   so daemon shutdown also evicts every active subscriber.
- *
- * - `host.events.buildEvent` — deterministic helper. Params
- *   `{ message, conversationId? }`. Returns the `AssistantEvent` envelope a
- *   skill would otherwise construct locally — keeping event-id allocation
- *   and timestamp generation on the daemon side
- *   so skill processes do not drift on UUID / clock sources.
- */
-
-import { z } from "zod";
-
-import { buildAssistantEvent } from "../../runtime/assistant-event.js";
-import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
-import type { SkillIpcRoute } from "../skill-ipc-types.js";
-import type { SkillIpcStreamingRoute } from "../skill-ipc-types.js";
-
-// ---------------------------------------------------------------------------
-// Param schemas
-// ---------------------------------------------------------------------------
-
-/**
- * `AssistantEvent` wire shape accepted by `host.events.publish`. The
- * envelope fields (`id`, `emittedAt`, `message`) are required;
- * `conversationId` is optional. The `message` payload is an opaque JSON
- * object — the daemon does not narrow it before handing it to
- * `assistantEventHub.publish`, matching the in-process hub contract.
- */
-const AssistantEventSchema = z.object({
-  id: z.string().min(1),
-  conversationId: z.string().optional(),
-  emittedAt: z.string().min(1),
-  message: z.record(z.string(), z.unknown()),
-});
-
-const PublishParams = z.object({
-  event: AssistantEventSchema,
-});
-
-const FilterSchema = z.object({
-  conversationId: z.string().optional(),
-});
-
-const SubscribeParams = z.object({
-  filter: FilterSchema,
-});
-
-const BuildEventParams = z.object({
-  message: z.record(z.string(), z.unknown()),
-  conversationId: z.string().optional(),
-});
-
-// ---------------------------------------------------------------------------
-// Event-type blocklist
-// ---------------------------------------------------------------------------
-
-/**
- * Message types that skills are NOT allowed to publish. These are
- * daemon→client control events that trigger host-side execution (bash,
- * file I/O, browser automation, credential prompts) or register pending
- * interactions. Allowing a skill to publish them would bypass the
- * trust/approval gates and escape the skill isolation boundary.
- *
- * Prefix-based: any event whose `type` starts with `"host_"` is blocked,
- * covering current types (`host_bash_request`, `host_file_request`,
- * `host_browser_request`, `host_cu_request`, `host_transfer_request`,
- * and their `_cancel` counterparts) plus any future `host_*` additions.
- */
-function isBlockedEventType(type: unknown): boolean {
-  if (typeof type !== "string") return true;
-  if (type.startsWith("host_")) return true;
-  if (type === "confirmation_request") return true;
-  if (type === "secret_request") return true;
-  return false;
-}
-
-// ---------------------------------------------------------------------------
-// Handlers
-// ---------------------------------------------------------------------------
-
-async function handlePublish(
-  params?: Record<string, unknown>,
-): Promise<{ published: true }> {
-  const { event } = PublishParams.parse(params);
-  const msgType = (event.message as Record<string, unknown>)?.type;
-  if (isBlockedEventType(msgType)) {
-    throw new Error(
-      `Skills cannot publish events of type "${String(msgType)}"`,
-    );
-  }
-  await assistantEventHub.publish(event as never);
-  return { published: true };
-}
-
-function handleBuildEvent(params?: Record<string, unknown>): unknown {
-  const { message, conversationId } = BuildEventParams.parse(params);
-  return buildAssistantEvent(message as never, conversationId);
-}
-
-// ---------------------------------------------------------------------------
-// Route exports
-// ---------------------------------------------------------------------------
-
-export const eventsRoutes: SkillIpcRoute[] = [
-  { method: "host.events.publish", handler: handlePublish },
-  { method: "host.events.buildEvent", handler: handleBuildEvent },
-];
-
-export const eventsStreamingRoutes: SkillIpcStreamingRoute[] = [
-  {
-    method: "host.events.subscribe",
-    handler: (stream, params) => {
-      const { filter } = SubscribeParams.parse(params);
-      const subscription = assistantEventHub.subscribe({
-        type: "process",
-        filter,
-        callback: (event) => {
-          stream.send(event);
-        },
-        onEvict: () => stream.close("subscription evicted by hub cap"),
-      });
-      return () => {
-        subscription.dispose();
-      };
-    },
-  },
-];

package/src/ipc/skill-routes/identity.ts

@@ -1,21 +0,0 @@
-/**
- * Skill IPC route: `host.identity.getAssistantName`.
- *
- * Reads the assistant's display name from IDENTITY.md, normalizing the
- * daemon helper's `null` to `undefined` (serialized as `null` over JSON,
- * which clients translate back to `undefined`).
- */
-
-import { getAssistantName } from "../../daemon/identity-helpers.js";
-import type { SkillIpcRoute } from "../skill-ipc-types.js";
-
-export const hostIdentityGetAssistantNameRoute: SkillIpcRoute = {
-  method: "host.identity.getAssistantName",
-  handler: () => {
-    return getAssistantName() ?? null;
-  },
-};
-
-export const identityRoutes: SkillIpcRoute[] = [
-  hostIdentityGetAssistantNameRoute,
-];

package/src/ipc/skill-routes/index.ts

@@ -1,37 +0,0 @@
-import type { SkillIpcRoute } from "../skill-ipc-types.js";
-import type { SkillIpcStreamingRoute } from "../skill-ipc-types.js";
-import { configRoutes } from "./config.js";
-import { eventsRoutes, eventsStreamingRoutes } from "./events.js";
-import { identityRoutes } from "./identity.js";
-import { logRoutes } from "./log.js";
-import { memorySkillRoutes } from "./memory.js";
-import { platformRoutes } from "./platform.js";
-import { providerSkillRoutes } from "./providers.js";
-import { registriesRoutes } from "./registries.js";
-
-/**
- * Skill IPC routes — host capabilities exposed to first-party skill processes
- * over the `assistant-skill.sock` socket.
- *
- * Populated incrementally by the skill-isolation plan PRs (host.log,
- * host.config.*, host.identity.*, host.platform.*, host.memory.*,
- * host.providers.*, host.events.*, host.registries.*).
- */
-export const skillIpcRoutes: SkillIpcRoute[] = [
-  ...logRoutes,
-  ...configRoutes,
-  ...identityRoutes,
-  ...platformRoutes,
-  ...memorySkillRoutes,
-  ...providerSkillRoutes,
-  ...registriesRoutes,
-  ...eventsRoutes,
-];
-
-/**
- * Long-lived streaming skill IPC routes. Handlers return a dispose callback
- * invoked on client disconnect, explicit close, or daemon shutdown.
- */
-export const skillIpcStreamingRoutes: SkillIpcStreamingRoute[] = [
-  ...eventsStreamingRoutes,
-];

package/src/ipc/skill-routes/log.ts

@@ -1,40 +0,0 @@
-/**
- * Skill IPC route: `host.log`.
- *
- * Forwards structured log lines from an out-of-process skill to the daemon's
- * existing logger so skill logs land in the same sink as daemon logs. The
- * skill-side contract uses `(msg, meta?)`; the daemon's pino loggers use
- * `(meta, msg)` — this route normalizes the call shape at the boundary,
- * matching `DaemonSkillHost.logger.get()`.
- */
-
-import { z } from "zod";
-
-import { getLogger } from "../../util/logger.js";
-import type { SkillIpcRoute } from "../skill-ipc-types.js";
-
-const LogParams = z.object({
-  level: z.enum(["debug", "info", "warn", "error"]),
-  msg: z.string(),
-  // Skill-chosen logger scope (mirrors `host.logger.get(name)` on the client
-  // side). Optional so callers that don't thread a scope still get a useful
-  // default instead of failing validation.
-  name: z.string().optional(),
-  meta: z.unknown().optional(),
-});
-
-export const hostLogRoute: SkillIpcRoute = {
-  method: "host.log",
-  handler: (params) => {
-    const { level, msg, name, meta } = LogParams.parse(params);
-    const log = getLogger(name ?? "skill");
-    const metaObj =
-      meta && typeof meta === "object" && !Array.isArray(meta)
-        ? (meta as Record<string, unknown>)
-        : {};
-    log[level](metaObj, msg);
-    return { ok: true };
-  },
-};
-
-export const logRoutes: SkillIpcRoute[] = [hostLogRoute];