@peers-app/peers-sdk 0.25.21 → 0.26.1

package/dist/contracts/__tests__/tool-catalog-service.test.js

@@ -0,0 +1,446 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../index");
+const tools_1 = require("../../data/tools");
+const system_ids_1 = require("../../system-ids");
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+const contract_provider_router_1 = require("../contract-provider-router");
+const contract_resolvers_1 = require("../contract-resolvers");
+const registry_1 = require("../registry");
+const tool_catalog_identity_1 = require("../tool-catalog-identity");
+const tool_catalog_service_1 = require("../tool-catalog-service");
+function fixture() {
+    const target = { contractId: (0, utils_1.newid)(), version: 1, toolName: "run" };
+    const provider = (0, utils_1.newid)();
+    const registry = new registry_1.ContractRegistry();
+    const definition = {
+        contractId: target.contractId,
+        version: 1,
+        devTag: "dev",
+        name: "Test",
+        description: "",
+        tables: [],
+        observables: [],
+        events: [],
+        tools: [
+            {
+                name: "run",
+                usageDescription: "run",
+                inputFields: [{ name: "value", type: field_type_1.FieldType.string }],
+                outputFields: [],
+            },
+        ],
+    };
+    const row = {
+        toolId: (0, tool_catalog_identity_1.deriveToolCatalogId)(target),
+        name: "run",
+        usageDescription: "run",
+        code: "",
+        inputSchema: { type: tools_1.IOSchemaType.none, fields: [] },
+        outputSchema: { type: tools_1.IOSchemaType.none, fields: [] },
+        contractId: target.contractId,
+        contractVersion: 1,
+        toolName: "run",
+        catalogState: "resolved",
+        catalogIdentity: "deterministic",
+    };
+    const rows = new Map([[row.toolId, row]]);
+    const table = {
+        get: jest.fn(async (id) => rows.get(id)),
+        list: jest.fn(async (filter = {}, opts = {}) => [...rows.values()]
+            .filter((r) => (!filter.name || r.name === filter.name) &&
+            (!opts.textSearch || r.name.includes(opts.textSearch)))
+            .slice(0, opts.pageSize)),
+    };
+    const endpoint = {
+        handleCall: jest.fn(async () => "ok"),
+        dispose: jest.fn(),
+    };
+    const loader = {
+        catalogReady: Promise.resolve(),
+        contractRegistry: registry,
+        toolCatalog: { assertTargetUsable: jest.fn(async () => { }) },
+        resolveContractEndpoint: jest.fn(async (_request, _options) => endpoint),
+        isolatedRuntime: {
+            isInstalled: jest.fn(() => false),
+            getEffectiveToolLevel: jest.fn(() => 40),
+            resolveEndpoint: jest.fn(),
+        },
+    };
+    const dataContext = {
+        dataContextId: (0, utils_1.newid)(),
+        tableContainer: {
+            getTable: (meta) => (meta.name === "Tools" ? table : { get: async () => undefined }),
+        },
+        packageLoader: loader,
+    };
+    const userId = (0, utils_1.newid)();
+    Object.assign(dataContext, {
+        userContext: {
+            userId,
+            loadingPromise: Promise.resolve(),
+            getDataContext: () => dataContext,
+            userDataContext: dataContext,
+        },
+    });
+    const context = { callerUserId: userId, localUserId: userId, dataContext };
+    const host = (packageId = provider, version = 1, accessLevel = 40) => {
+        (0, contract_resolvers_1.stagePackageContractResolvers)(dataContext, packageId, () => (0, contract_resolvers_1.registerContractResolver)(target.contractId, version, () => ({
+            contractId: target.contractId,
+            version,
+            tools: { run: { tool: { ...row, accessLevel }, toolFn: () => "ok" } },
+        }), { providerPackageId: packageId }))();
+    };
+    const install = () => {
+        expect(registry.register(provider, definition).valid).toBe(true);
+        host();
+    };
+    return {
+        target,
+        provider,
+        registry,
+        definition,
+        row,
+        rows,
+        table,
+        endpoint,
+        loader,
+        dataContext,
+        context,
+        host,
+        install,
+    };
+}
+test("classifies missing providers, missing members, quarantine, missing implementations and removed legacy execution", async () => {
+    const f = fixture();
+    const describe = () => (0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, f.row);
+    expect(describe().availability.reason).toBe("no-provider");
+    f.registry.register(f.provider, f.definition);
+    expect(describe().availability.reason).toBe("no-implementation");
+    f.host();
+    expect(describe().availability.dispatch).toBe("contract");
+    f.definition.tools = [];
+    expect(describe().availability.reason).toBe("member-removed");
+    f.row.catalogState = "quarantined";
+    expect(describe().availability.reason).toBe("quarantined");
+    f.row.contractId = (0, utils_1.newid)();
+    expect(describe().availability.reason).toBe("invalid-identity");
+    const legacy = {
+        ...f.row,
+        toolId: (0, utils_1.newid)(),
+        contractId: undefined,
+        contractVersion: undefined,
+        toolName: undefined,
+        catalogIdentity: undefined,
+        catalogState: "unresolved",
+    };
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, legacy).availability.reason).toBe("legacy-execution-removed");
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, legacy).availability.message).toContain("contract resolver");
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, { ...legacy, packageId: f.provider }).availability).toMatchObject({
+        dispatch: "unavailable",
+        reason: "legacy-package-upgrade-required",
+        message: expect.stringContaining(f.provider),
+    });
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, legacy).availability.dispatch).toBe("unavailable");
+});
+test("projects aliases including the shipped Scheduler ID and groups equal name matches", async () => {
+    const f = fixture();
+    const alias = {
+        ...f.row,
+        toolId: "00muxgugn661g0qmpuwafrmsi4",
+        contractId: system_ids_1.schedulerContractId,
+        toolName: "list",
+        catalogIdentity: "legacy-alias",
+    };
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, alias).aliases).toEqual([alias.toolId]);
+    f.rows.clear();
+    const aliases = ["00muxoa8xeet2lpi8bdq55q03", "00muxob3hbo3f6g49mipy1hyt"];
+    for (const toolId of aliases)
+        f.rows.set(toolId, {
+            ...alias,
+            toolId,
+            contractId: "00muxgugn6xvs8f2r80ru205t",
+            toolName: "invoke",
+            name: "invoke",
+        });
+    expect((await (0, tool_catalog_service_1.findToolCatalogEntry)(f.dataContext, { toolIdOrName: "invoke" }))?.aliases).toEqual(aliases);
+});
+test.each([
+    "authority",
+    "assistantId",
+    "workflowVars",
+    "callerPackageId",
+])("rejects payload key %s", async (key) => {
+    const f = fixture();
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: f.row.toolId, [key]: { userAccessLevel: 100 } }, f.context)).rejects.toThrow("Unexpected invokeTool input key");
+    expect(f.loader.resolveContractEndpoint).not.toHaveBeenCalled();
+});
+test.each([
+    { callerPackageId: system_ids_1.peersSystemPackageId },
+    { callerDeviceId: (0, utils_1.newid)() },
+    { callerUserId: undefined, localUserId: undefined },
+    { dataContext: {} },
+])("rejects unauthenticated, package, device and cross-context callers: %j", async (override) => {
+    const f = fixture();
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: f.row.toolId }, {
+        ...f.context,
+        ...override,
+    })).rejects.toThrow();
+    expect(f.loader.resolveContractEndpoint).not.toHaveBeenCalled();
+});
+test("validates arguments, converts dates, and forwards original nested objects and unknown fields", async () => {
+    const f = fixture();
+    f.install();
+    const invoke = (args) => (0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: f.row.toolId, args }, f.context);
+    for (const args of [undefined, [], null, "bad", { value: 4 }])
+        await expect(invoke(args)).rejects.toThrow();
+    f.definition.tools[0].inputFields.push({ name: "when", type: field_type_1.FieldType.Date }, { name: "object", type: field_type_1.FieldType.object }, { name: "defaulted", type: field_type_1.FieldType.string, defaultValue: "default" });
+    const object = { nested: "retained" };
+    const args = { value: "hello", when: "2026-10-16", object, extra: 1 };
+    await expect(invoke(args)).resolves.toBe("ok");
+    const forwarded = f.endpoint.handleCall.mock.calls[0][0].args[0];
+    expect(forwarded).toEqual({ ...args, when: new Date(args.when) });
+    expect(forwarded.object).toBe(object);
+    expect(forwarded).not.toHaveProperty("defaulted");
+    expect(args.when).toBe("2026-10-16");
+    await expect(invoke({ ...args, when: "not-a-date" })).rejects.toThrow("argument validation");
+    expect(f.endpoint.dispose).toHaveBeenCalledTimes(1);
+});
+test("selects strict, preferred and fallback providers and observes active changes under the same ID", async () => {
+    const f = fixture();
+    f.install();
+    const second = (0, utils_1.newid)();
+    f.registry.register(second, f.definition);
+    f.host(second);
+    const invoke = (input = {}) => (0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: f.row.toolId, args: { value: "ok" }, ...input }, f.context);
+    await expect(invoke({ providerPackageId: (0, utils_1.newid)() })).rejects.toThrow("Strict provider selection");
+    await invoke({ providerPackageId: second });
+    expect(f.loader.resolveContractEndpoint.mock.calls.at(-1)?.[0]).toMatchObject({
+        providerPackageId: second,
+    });
+    await invoke({ providerPackageId: (0, utils_1.newid)(), fallbackToDefaultProvider: true });
+    expect(f.loader.resolveContractEndpoint.mock.calls.at(-1)?.[0]).toMatchObject({
+        providerPackageId: f.provider,
+    });
+    f.registry.setActiveProvider(f.target.contractId, 1, second);
+    await invoke();
+    expect(f.loader.resolveContractEndpoint.mock.calls.at(-1)?.[0]).toMatchObject({
+        providerPackageId: second,
+        context: f.context,
+    });
+    expect(f.endpoint.handleCall).toHaveBeenLastCalledWith(expect.objectContaining({ args: [{ value: "ok" }] }), f.context);
+});
+test("host alsoImplements validates the requested v1 schema and resolves v2 code", async () => {
+    const f = fixture();
+    f.registry.register((0, utils_1.newid)(), f.definition);
+    const newer = {
+        ...f.definition,
+        version: 2,
+        tools: [
+            {
+                ...f.definition.tools[0],
+                inputFields: [
+                    ...f.definition.tools[0].inputFields,
+                    { name: "new", type: field_type_1.FieldType.number, optional: true },
+                ],
+            },
+        ],
+    };
+    expect(f.registry.register(f.provider, newer, [{ contractId: f.target.contractId, version: 1 }]).valid).toBe(true);
+    f.registry.setActiveProvider(f.target.contractId, 1, f.provider);
+    f.host(f.provider, 2);
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, f.row).provider?.implementation?.version).toBe(2);
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: f.row.toolId, args: { value: "v1", new: "not a v2 number" } }, f.context)).resolves.toBe("ok");
+});
+test("rejects self targets, unresolved and quarantined rows, and never uses legacy invocation", async () => {
+    const f = fixture();
+    for (const row of [
+        { ...f.row, catalogState: "quarantined" },
+        {
+            ...f.row,
+            toolId: (0, utils_1.newid)(),
+            contractId: undefined,
+            contractVersion: undefined,
+            toolName: undefined,
+            catalogIdentity: undefined,
+            catalogState: "unresolved",
+        },
+        {
+            ...f.row,
+            toolId: (0, tool_catalog_identity_1.deriveToolCatalogId)({
+                contractId: system_ids_1.toolCatalogContractId,
+                version: 1,
+                toolName: "invokeTool",
+            }),
+            contractId: system_ids_1.toolCatalogContractId,
+            toolName: "invokeTool",
+        },
+    ]) {
+        f.rows.set(row.toolId, row);
+        await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: row.toolId }, f.context)).rejects.toThrow();
+    }
+    f.rows.set(f.row.toolId, f.row);
+    f.registry.register(f.provider, f.definition);
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: f.row.toolId, args: { value: "ok" } }, f.context)).rejects.toThrow("no-implementation");
+    expect(f.loader.resolveContractEndpoint).not.toHaveBeenCalled();
+});
+test.each([
+    "own",
+    "downstream",
+    "failure",
+    "twice",
+])("disposes endpoints and retries only its own first retirement: %s", async (mode) => {
+    const f = fixture();
+    f.install();
+    const next = { handleCall: jest.fn(async () => "next"), dispose: jest.fn() };
+    const replacement = (0, utils_1.newid)();
+    f.registry.register(replacement, f.definition);
+    f.host(replacement);
+    if (mode === "own")
+        f.loader.resolveContractEndpoint.mockImplementationOnce(async () => {
+            f.registry.setActiveProvider(f.target.contractId, 1, replacement);
+            return f.endpoint;
+        });
+    if (mode !== "own")
+        f.loader.resolveContractEndpoint.mockResolvedValueOnce(f.endpoint);
+    f.loader.resolveContractEndpoint.mockResolvedValueOnce(next);
+    f.endpoint.handleCall.mockRejectedValueOnce(mode === "failure"
+        ? new Error("failed")
+        : new contract_provider_router_1.RetiredContractProviderEndpointError(mode === "downstream" ? next : f.endpoint));
+    if (mode === "twice")
+        next.handleCall.mockRejectedValueOnce(new contract_provider_router_1.RetiredContractProviderEndpointError(next));
+    const invoking = (0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: f.row.toolId, args: { value: "ok" } }, f.context);
+    if (mode === "own") {
+        await expect(invoking).resolves.toBe("next");
+        expect(f.loader.resolveContractEndpoint.mock.calls.at(-1)?.[0].providerPackageId).toBe(replacement);
+    }
+    else
+        await expect(invoking).rejects.toThrow();
+    expect(f.endpoint.dispose).toHaveBeenCalledTimes(1);
+    expect(f.loader.resolveContractEndpoint).toHaveBeenCalledTimes(mode === "own" || mode === "twice" ? 2 : 1);
+    expect(next.dispose).toHaveBeenCalledTimes(mode === "own" || mode === "twice" ? 1 : 0);
+});
+test("waits for readiness, bounds discovery, and projects live access without resolving an endpoint", async () => {
+    const f = fixture();
+    f.install();
+    await (0, tool_catalog_service_1.listToolCatalogEntries)(f.dataContext, { limit: 900, query: "ru" });
+    expect(f.table.list).toHaveBeenCalledWith({}, { pageSize: 500, textSearch: "ru" });
+    expect((await (0, tool_catalog_service_1.findToolCatalogEntry)(f.dataContext, { toolIdOrName: f.row.toolId }, f.context))?.access).toEqual({ accessLevel: 40, callerAccessLevel: 100, allowed: true });
+    f.loader.isolatedRuntime.isInstalled.mockReturnValue(true);
+    expect((await (0, tool_catalog_service_1.findToolCatalogEntry)(f.dataContext, { toolIdOrName: "run" }, f.context))?.access
+        ?.accessLevel).toBe(40);
+    expect(f.loader.isolatedRuntime.resolveEndpoint).not.toHaveBeenCalled();
+    expect(f.loader.resolveContractEndpoint).not.toHaveBeenCalled();
+    let ready;
+    f.loader.catalogReady = new Promise((resolve) => {
+        ready = resolve;
+    });
+    f.table.list.mockClear();
+    const pending = (0, tool_catalog_service_1.listToolCatalogEntries)(f.dataContext);
+    await Promise.resolve();
+    expect(f.table.list).not.toHaveBeenCalled();
+    ready();
+    await pending;
+});
+test("an old bundle declaring a member without a resolver reports no implementation", () => {
+    const f = fixture();
+    f.registry.register(f.provider, f.definition);
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, f.row).availability).toEqual({
+        dispatch: "unavailable",
+        reason: "no-implementation",
+        message: expect.stringContaining(`Provider ${f.provider} declares run but registers no implementation`),
+    });
+});
+test("workflow requirement is projected and enforced in the matching host context", async () => {
+    const f = fixture();
+    f.definition.tools[0].requiresWorkflowRun = true;
+    f.install();
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, f.row)).toMatchObject({
+        workflowInvocable: true,
+        availability: { requiresWorkflowRun: true },
+    });
+    const input = { toolId: f.row.toolId, args: { value: "x" } };
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, f.context)).rejects.toThrow("requires a host workflow");
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, {
+        ...f.context,
+        workflow: { dataContextId: "elsewhere" },
+    })).rejects.toThrow("does not match");
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, {
+        ...f.context,
+        workflow: { dataContextId: f.dataContext.dataContextId },
+    })).resolves.toBe("ok");
+});
+test("remote catalog callers require host opt-in and retain identity; local-only targets reject", async () => {
+    const f = fixture();
+    f.install();
+    const remote = { ...f.context, callerDeviceId: (0, utils_1.newid)(), callerUserId: (0, utils_1.newid)() };
+    const input = { toolId: f.row.toolId, args: { value: "x" } };
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, remote)).rejects.toThrow("local user");
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, remote, { allowRemoteCaller: true })).resolves.toBe("ok");
+    expect(f.endpoint.handleCall).toHaveBeenCalledWith(expect.anything(), remote);
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, { ...remote, callerPackageId: (0, utils_1.newid)() }, { allowRemoteCaller: true })).rejects.toThrow("local user");
+    const { hostToolsContractId, getHostToolsContractDefinition } = require("../../index");
+    const { toolCatalogIds } = require("../tool-catalog-migrations");
+    const target = { contractId: hostToolsContractId, version: 1, toolName: "create-group" };
+    const row = {
+        ...f.row,
+        toolId: toolCatalogIds(target)[0],
+        contractId: target.contractId,
+        toolName: target.toolName,
+        catalogIdentity: "legacy-alias",
+    };
+    f.rows.set(row.toolId, row);
+    f.registry.register(system_ids_1.peersSystemPackageId, getHostToolsContractDefinition());
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, { toolId: row.toolId }, remote, {
+        allowRemoteCaller: true,
+    })).rejects.toThrow("local-only");
+});
+test("workflow invocability excludes administrative systems and unavailable tools", () => {
+    const f = fixture();
+    f.install();
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, f.row).workflowInvocable).toBe(true);
+    f.registry.unregister(f.provider);
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, f.row).workflowInvocable).toBe(false);
+    const sdk = require("../../index");
+    const ids = require("../tool-catalog-migrations");
+    for (const [definition, name, allowed] of [
+        [sdk.getHostToolsContractDefinition(), "tool-search", true],
+        [sdk.getToolAccessControlContractDefinition(), "approve", false],
+        [sdk.getIdentityContractDefinition(), "signIn", false],
+    ]) {
+        f.registry.register(system_ids_1.peersSystemPackageId, definition);
+        const target = { contractId: definition.contractId, version: 1, toolName: name };
+        const row = {
+            ...f.row,
+            toolId: ids.toolCatalogIds(target)[0],
+            contractId: target.contractId,
+            toolName: name,
+            catalogIdentity: "legacy-alias",
+        };
+        f.loader.isolatedRuntime.isInstalled.mockReturnValue(true);
+        expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, row).workflowInvocable).toBe(allowed);
+    }
+    const legacy = {
+        ...f.row,
+        toolId: (0, utils_1.newid)(),
+        contractId: undefined,
+        contractVersion: undefined,
+        toolName: undefined,
+        catalogState: "unresolved",
+        catalogIdentity: undefined,
+    };
+    expect((0, tool_catalog_service_1.describeToolCatalogRow)(f.dataContext, legacy).workflowInvocable).toBe(false);
+});
+test("workflow admission rejects a newly raised provider level and strips workflow from isolates", async () => {
+    const f = fixture();
+    f.install();
+    const context = { ...f.context, workflow: { dataContextId: f.dataContext.dataContextId } };
+    const input = { toolId: f.row.toolId, args: { value: "x" } };
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, context, { maxAccessLevel: 20 })).rejects.toThrow("exceeds the authorized");
+    f.loader.isolatedRuntime.isInstalled.mockReturnValue(true);
+    await (0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, context, { maxAccessLevel: 40 });
+    expect(f.loader.resolveContractEndpoint.mock.calls[0][0].context.workflow).toBeUndefined();
+    expect(f.endpoint.handleCall.mock.calls[0][1].workflow).toBeUndefined();
+    await expect((0, tool_catalog_service_1.invokeToolCatalogTool)(f.dataContext, input, { ...f.context, callerUserId: undefined, callerDeviceId: (0, utils_1.newid)() }, { allowRemoteCaller: true })).rejects.toThrow("caller user identity");
+});

package/dist/contracts/__tests__/tool-catalog.test.d.ts

@@ -0,0 +1 @@
+import "../../index";