@peers-app/peers-sdk 0.27.3 → 0.27.5

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

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("../../index");
-const systemIds = require("../../system-ids");
-const system_ids_1 = require("../../system-ids");
-const system_contracts_1 = require("../system-contracts");
-const tool_catalog_identity_1 = require("../tool-catalog-identity");
-const tool_catalog_migrations_1 = require("../tool-catalog-migrations");
-test("every reviewed alias is valid and the workflow migration leaves no unresolved tools", () => {
-    for (const entry of tool_catalog_migrations_1.toolCatalogMigrations) {
-        expect((0, tool_catalog_identity_1.isCatalogToolId)(entry.toolId)).toBe(true);
-        expect((0, tool_catalog_migrations_1.resolveLegacyToolId)(entry.toolId)).toEqual({
-            contractId: entry.contractId,
-            version: entry.version,
-            toolName: entry.toolName,
-        });
-    }
-    for (const [id, contractId, toolName] of [
-        ["000peers0tool00000runner1", system_ids_1.hostToolsContractId, "default_assistant_runner"],
-        ["000peers0tool00toolsearch", system_ids_1.hostToolsContractId, "tool-search"],
-        ["000peers0tool0000000dircd", system_ids_1.desktopToolsContractId, "cd"],
-        ["000peers0tool000000notify", system_ids_1.desktopToolsContractId, "send-notification"],
-    ])
-        expect((0, tool_catalog_migrations_1.resolveLegacyToolId)(id)).toEqual({ contractId, version: 1, toolName });
-});
-test("all system aliases name declared members and every system ID map is reviewed", () => {
-    for (const alias of tool_catalog_migrations_1.toolCatalogMigrations) {
-        if (!(0, system_contracts_1.isSystemContractId)(alias.contractId))
-            continue;
-        const system = (0, system_contracts_1.listSystemContracts)().find((entry) => {
-            const definition = entry.getDefinition();
-            return definition.contractId === alias.contractId && definition.version === alias.version;
-        });
-        expect(system).toBeDefined();
-        expect(system?.getDefinition().tools.some((tool) => tool.name === alias.toolName)).toBe(true);
-    }
-    for (const [name, ids] of Object.entries(systemIds)) {
-        if (!name.endsWith("ToolIds"))
-            continue;
-        for (const toolId of Object.values(ids))
-            expect((0, tool_catalog_migrations_1.resolveLegacyToolId)(toolId)).toBeDefined();
-    }
-    expect((0, tool_catalog_migrations_1.resolveLegacyToolId)("00mh0wlipkdbeaw8imptsk001")).toBeUndefined();
-});

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

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

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

@@ -1,482 +0,0 @@
-"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");
-    await expect(invoke({ ...args, defaulted: null })).resolves.toBe("ok");
-    expect(f.endpoint.handleCall.mock.calls[1][0].args[0]).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(2);
-});
-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");
-    // By name, the v1 row and the v2 row run the same tool: the v2 row is chosen, not "ambiguous".
-    const v2Target = { ...f.target, version: 2 };
-    const v2Row = {
-        ...f.row,
-        toolId: (0, tool_catalog_identity_1.deriveToolCatalogId)(v2Target),
-        contractVersion: 2,
-    };
-    f.rows.set(v2Row.toolId, v2Row);
-    await expect((0, tool_catalog_service_1.findToolCatalogEntry)(f.dataContext, { toolIdOrName: "run", runnableOnly: true })).resolves.toMatchObject({ toolId: v2Row.toolId });
-});
-test("name lookup keeps aliases ambiguous when the implementing version selects another provider", async () => {
-    const f = fixture();
-    const newer = { ...f.definition, version: 2 };
-    expect(f.registry.register(f.provider, newer, [
-        { contractId: f.target.contractId, version: 1, definition: f.definition },
-    ]).valid).toBe(true);
-    f.host(f.provider, 2);
-    const other = (0, utils_1.newid)();
-    expect(f.registry.register(other, newer).valid).toBe(true);
-    f.host(other, 2);
-    expect(f.registry.setActiveProvider(f.target.contractId, 2, other)).toBe(true);
-    const v2Row = {
-        ...f.row,
-        toolId: (0, tool_catalog_identity_1.deriveToolCatalogId)({ ...f.target, version: 2 }),
-        contractVersion: 2,
-    };
-    f.rows.set(v2Row.toolId, v2Row);
-    await expect((0, tool_catalog_service_1.findToolCatalogEntry)(f.dataContext, { toolIdOrName: "run", runnableOnly: true })).rejects.toThrow('Ambiguous tool "run": matched 2 tools');
-    for (const [row, provider] of [
-        [f.row, f.provider],
-        [v2Row, other],
-    ]) {
-        await expect((0, tool_catalog_service_1.findToolCatalogEntry)(f.dataContext, { toolIdOrName: row.toolId, runnableOnly: true })).resolves.toMatchObject({ provider: { activePackageId: provider } });
-    }
-});
-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

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