@tyvm/knowhow 0.0.159 → 0.0.161

package/tests/unit/services/SyncedAgentWatcher.test.ts

@@ -1,89 +0,0 @@
-import { FsSyncedAgentWatcher } from "../../../src/services/watchers/FsSyncer";
-import { WebSyncedAgentWatcher } from "../../../src/services/watchers/RemoteSyncer";
-
-const retained = { role: "assistant", content: "before compaction" };
-const oldThread = [
-  { role: "system", content: "instructions" },
-  { role: "user", content: "task" },
-  retained,
-];
-const compactedThread = [
-  { role: "system", content: "instructions" },
-  { role: "user", content: "compressed summary" },
-  retained,
-  { role: "assistant", content: "after compaction" },
-];
-
-function seedCursor(watcher: any): void {
-  watcher.taskId = "task-1";
-  watcher.agentName = "Developer";
-  watcher.lastThreadIndex = 0;
-  watcher.lastThreadLength = oldThread.length;
-  watcher.lastMessageJson = JSON.stringify(retained);
-}
-
-describe("synced agent watcher thread rollover", () => {
-  it("continues rendering after filesystem agent compaction", async () => {
-    const watcher: any = new FsSyncedAgentWatcher();
-    seedCursor(watcher);
-    watcher.readMetadata = jest.fn().mockResolvedValue({
-      threads: [oldThread, compactedThread],
-      status: "running",
-    });
-
-    const messages: string[] = [];
-    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
-      messages.push(data.message);
-    });
-
-    await watcher.onMetadataChanged();
-
-    expect(messages).toEqual(["after compaction"]);
-    expect(watcher.lastThreadIndex).toBe(1);
-    expect(watcher.lastThreadLength).toBe(compactedThread.length);
-  });
-
-  it("continues rendering after web agent compaction", async () => {
-    const client = {
-      getTaskDetails: jest.fn().mockResolvedValue({
-        data: {
-          threads: [oldThread, compactedThread],
-          status: "running",
-        },
-      }),
-    };
-    const watcher: any = new WebSyncedAgentWatcher(client as any);
-    seedCursor(watcher);
-
-    const messages: string[] = [];
-    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
-      messages.push(data.message);
-    });
-
-    await watcher.onPoll();
-
-    expect(messages).toEqual(["after compaction"]);
-    expect(watcher.lastThreadIndex).toBe(1);
-    expect(watcher.lastThreadLength).toBe(compactedThread.length);
-  });
-
-  it("resets a cursor when a thread shrinks without changing index", async () => {
-    const watcher: any = new FsSyncedAgentWatcher();
-    seedCursor(watcher);
-    watcher.lastThreadLength = 10;
-    watcher.readMetadata = jest.fn().mockResolvedValue({
-      threads: [compactedThread],
-      status: "running",
-    });
-
-    const messages: string[] = [];
-    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
-      messages.push(data.message);
-    });
-
-    await watcher.onMetadataChanged();
-
-    expect(messages).toEqual(["after compaction"]);
-    expect(watcher.lastThreadLength).toBe(compactedThread.length);
-  });
-});

package/tests/unit/services/SyncerService.test.ts

@@ -1,45 +0,0 @@
-import { AgentSyncFs } from "../../../src/services/AgentSyncFs";
-import { SyncerService } from "../../../src/services/SyncerService";
-
-describe("SyncerService remote identity", () => {
-  beforeEach(() => {
-    jest
-      .spyOn(AgentSyncFs.prototype, "createTask")
-      .mockImplementation(async (options) => options.taskId);
-    jest
-      .spyOn(AgentSyncFs.prototype, "setRemoteIdentity")
-      .mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it("never attaches a local filesystem slug as a remote task", async () => {
-    const syncer = new SyncerService();
-    await syncer.createTask({
-      taskId: "1785905990-local-task-slug",
-      prompt: "resume",
-      syncRemote: true,
-    });
-
-    expect(syncer.getCreatedWebTaskId()).toBeUndefined();
-    expect(AgentSyncFs.prototype.setRemoteIdentity).not.toHaveBeenCalled();
-  });
-
-  it("attaches and persists an explicit remote task UUID", async () => {
-    const remoteTaskId = "123e4567-e89b-42d3-a456-426614174000";
-    const syncer = new SyncerService();
-    await syncer.createTask({
-      taskId: "1785905990-local-task-slug",
-      remoteTaskId,
-      prompt: "resume",
-      syncRemote: true,
-    });
-
-    expect(syncer.getCreatedWebTaskId()).toBe(remoteTaskId);
-    expect(AgentSyncFs.prototype.setRemoteIdentity).toHaveBeenCalledWith(
-      remoteTaskId
-    );
-  });
-});

package/tests/unit/tunnel.test.ts

@@ -1,51 +0,0 @@
-import { extractTunnelDomain } from "../../src/tunnel";
-
-describe("extractTunnelDomain", () => {
-  const originalTunnelWorkerDomain = process.env.TUNNEL_WORKER_DOMAIN;
-
-  beforeEach(() => {
-    delete process.env.TUNNEL_WORKER_DOMAIN;
-  });
-
-  afterAll(() => {
-    if (originalTunnelWorkerDomain === undefined) {
-      delete process.env.TUNNEL_WORKER_DOMAIN;
-    } else {
-      process.env.TUNNEL_WORKER_DOMAIN = originalTunnelWorkerDomain;
-    }
-  });
-
-  it("uses the local tunnel proxy for a localhost API URL", () => {
-    expect(extractTunnelDomain("http://localhost:4000")).toEqual({
-      domain: "worker.localhost:4000",
-      useHttps: false,
-    });
-  });
-
-  it("uses the local tunnel proxy for loopback API URLs", () => {
-    expect(extractTunnelDomain("http://127.0.0.1:4000")).toEqual({
-      domain: "worker.localhost:4000",
-      useHttps: false,
-    });
-  });
-
-  it("continues to select dev and production tunnel domains", () => {
-    expect(extractTunnelDomain("https://api.dev.knowhow.tyvm.ai")).toEqual({
-      domain: "worker.dev.tyvm-apps.com",
-      useHttps: true,
-    });
-    expect(extractTunnelDomain("https://api.knowhow.tyvm.ai")).toEqual({
-      domain: "worker.tyvm-apps.com",
-      useHttps: true,
-    });
-  });
-
-  it("allows an explicit tunnel domain to override localhost detection", () => {
-    process.env.TUNNEL_WORKER_DOMAIN = "worker.override.example";
-
-    expect(extractTunnelDomain("http://localhost:4000")).toEqual({
-      domain: "worker.override.example",
-      useHttps: false,
-    });
-  });
-});

package/tests/unit/util/Trace.test.ts

@@ -1,119 +0,0 @@
-import { Trace, TraceAll } from "../../../src/util/Trace";
-import {
-  SpanHandle,
-  TracerImpl,
-  TracingService,
-} from "../../../src/services/TracingService";
-import { ToolsService } from "../../../src/services/Tools";
-
-class TestSpan implements SpanHandle {
-  ended = false;
-  error?: unknown;
-
-  setAttribute() {}
-
-  recordError(error: unknown) {
-    this.error = error;
-  }
-
-  end() {
-    this.ended = true;
-  }
-}
-
-class TestTracer implements TracerImpl {
-  spans: Array<{
-    name: string;
-    attributes?: Record<string, string | number | boolean>;
-    span: TestSpan;
-  }> = [];
-
-  startSpan(
-    name: string,
-    attributes?: Record<string, string | number | boolean>
-  ): SpanHandle {
-    const span = new TestSpan();
-    this.spans.push({ name, attributes, span });
-    return span;
-  }
-
-  withSpan<T>(_span: SpanHandle, fn: () => T): T {
-    return fn();
-  }
-}
-
-describe("tracing decorators", () => {
-  const tracer = new TestTracer();
-
-  beforeEach(() => {
-    tracer.spans = [];
-    TracingService.register(tracer);
-  });
-
-  afterAll(() => TracingService.reset());
-
-  it("traces and closes synchronous and asynchronous methods", async () => {
-    @TraceAll()
-    class Subject {
-      sync() {
-        return "sync";
-      }
-
-      async asyncMethod() {
-        return "async";
-      }
-    }
-
-    const subject = new Subject();
-    expect(subject.sync()).toBe("sync");
-    expect(await subject.asyncMethod()).toBe("async");
-
-    expect(tracer.spans.map(({ name }) => name)).toEqual([
-      "Subject.sync",
-      "Subject.asyncMethod",
-    ]);
-    expect(tracer.spans.every(({ span }) => span.ended)).toBe(true);
-  });
-
-  it("records rejected method errors before rethrowing them", async () => {
-    const failure = new Error("failed");
-
-    class Subject {
-      @Trace()
-      async fail() {
-        throw failure;
-      }
-    }
-
-    await expect(new Subject().fail()).rejects.toBe(failure);
-    expect(tracer.spans[0].span.error).toBe(failure);
-    expect(tracer.spans[0].span.ended).toBe(true);
-  });
-
-  it("traces the concrete ToolsService.callTool path", async () => {
-    const tools = new ToolsService();
-    tools.addTool({
-      type: "function",
-      function: {
-        name: "echo",
-        description: "Echo a value",
-        parameters: {
-          type: "object",
-          properties: { value: { type: "string" } },
-          required: ["value"],
-        },
-      },
-    });
-    tools.setFunction("echo", ({ value }: { value: string }) => value);
-
-    const result = await tools.callTool({
-      id: "trace-test",
-      type: "function",
-      function: { name: "echo", arguments: JSON.stringify({ value: "ok" }) },
-    });
-
-    expect(result.functionResp).toBe("ok");
-    expect(tracer.spans.some(({ name }) => name === "ToolsService.callTool"))
-      .toBe(true);
-  });
-});

package/tests/unit/utils/http.test.ts

@@ -1,43 +0,0 @@
-import http, { HTTP_UNAUTHORIZED_HANDLER, RefreshableHeaders } from "../../../src/utils/http";
-
-describe("HTTP unauthorized renewal", () => {
-  const originalFetch = global.fetch;
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-    jest.restoreAllMocks();
-  });
-
-  it("renews and retries a 401 once with the updated headers", async () => {
-    const headers: RefreshableHeaders = { Authorization: "Bearer old" };
-    const renew = jest.fn(async () => {
-      headers.Authorization = "Bearer new";
-    });
-    Object.defineProperty(headers, HTTP_UNAUTHORIZED_HANDLER, { value: renew });
-    global.fetch = jest
-      .fn()
-      .mockResolvedValueOnce(new Response("unauthorized", { status: 401 }))
-      .mockResolvedValueOnce(new Response(JSON.stringify({ ok: true }), { status: 200 }));
-
-    await expect(http.get("https://example.test", { headers })).resolves.toMatchObject({
-      data: { ok: true },
-    });
-    expect(renew).toHaveBeenCalledTimes(1);
-    expect(global.fetch).toHaveBeenNthCalledWith(
-      2,
-      "https://example.test",
-      expect.objectContaining({ headers: { Authorization: "Bearer new" } })
-    );
-  });
-
-  it("does not renew or retry a second 401", async () => {
-    const headers: RefreshableHeaders = { Authorization: "Bearer old" };
-    const renew = jest.fn(async () => undefined);
-    Object.defineProperty(headers, HTTP_UNAUTHORIZED_HANDLER, { value: renew });
-    global.fetch = jest.fn().mockResolvedValue(new Response("unauthorized", { status: 401 }));
-
-    await expect(http.get("https://example.test", { headers })).rejects.toMatchObject({ status: 401 });
-    expect(renew).toHaveBeenCalledTimes(1);
-    expect(global.fetch).toHaveBeenCalledTimes(2);
-  });
-});

package/ts_build/tests/XmlToolCallProcessor.test.d.ts

@@ -1 +0,0 @@
-export {};