@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/vaquill/actions.js

@@ -0,0 +1,529 @@
+import { defineProviderAction } from "../../core/provider-definition.js";
+import * as schemas from "./schemas.js";
+const vaquillOperations = [
+    {
+        name: "search_statutes",
+        method: "POST",
+        path: "/api/v1/us/statutes/search",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "search_statutes",
+            description: "Search US statutes, constitutions, court rules, and executive actions.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.search_statutesInput,
+            outputSchema: schemas.search_statutesOutput,
+        }),
+    },
+    {
+        name: "get_section",
+        method: "GET",
+        path: "/api/v1/us/statutes/section/{act_id}",
+        query: [],
+        pathKeys: ["act_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_section",
+            description: "Get statute section metadata.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_sectionInput,
+            outputSchema: schemas.get_sectionOutput,
+        }),
+    },
+    {
+        name: "resolve_citation",
+        method: "GET",
+        path: "/api/v1/us/statutes/resolve",
+        query: ["cite", "state", "corpusType"],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "resolve_citation",
+            description: "Resolve a citation to its section.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.resolve_citationInput,
+            outputSchema: schemas.resolve_citationOutput,
+        }),
+    },
+    {
+        name: "resolve_citations",
+        method: "POST",
+        path: "/api/v1/us/statutes/resolve",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "resolve_citations",
+            description: "Resolve many citations at once.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.resolve_citationsInput,
+            outputSchema: schemas.resolve_citationsOutput,
+        }),
+    },
+    {
+        name: "get_related_sections",
+        method: "GET",
+        path: "/api/v1/us/statutes/section/{act_id}/related",
+        query: ["limit"],
+        pathKeys: ["act_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_related_sections",
+            description: "Get the sections around this one.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_related_sectionsInput,
+            outputSchema: schemas.get_related_sectionsOutput,
+        }),
+    },
+    {
+        name: "get_sections",
+        method: "POST",
+        path: "/api/v1/us/statutes/sections",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "get_sections",
+            description: "Get metadata for many statute sections.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_sectionsInput,
+            outputSchema: schemas.get_sectionsOutput,
+        }),
+    },
+    {
+        name: "get_section_body",
+        method: "GET",
+        path: "/api/v1/us/statutes/section/{act_id}/body",
+        query: ["format", "structured", "asOf"],
+        pathKeys: ["act_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_section_body",
+            description: "Get statute full text.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_section_bodyInput,
+            outputSchema: schemas.get_section_bodyOutput,
+        }),
+    },
+    {
+        name: "count_statutes",
+        method: "POST",
+        path: "/api/v1/us/statutes/count",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "count_statutes",
+            description: "Count the sections in a scope.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.count_statutesInput,
+            outputSchema: schemas.count_statutesOutput,
+        }),
+    },
+    {
+        name: "get_coverage",
+        method: "GET",
+        path: "/api/v1/us/statutes/coverage",
+        query: ["state"],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "get_coverage",
+            description: "Coverage matrix by jurisdiction and corpusType.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_coverageInput,
+            outputSchema: schemas.get_coverageOutput,
+        }),
+    },
+    {
+        name: "list_divisions",
+        method: "GET",
+        path: "/api/v1/us/statutes/divisions",
+        query: [
+            "corpusType",
+            "state",
+            "titleNumber",
+            "code",
+            "chapter",
+            "part",
+            "article",
+            "excludeRepealed",
+            "actStatus",
+            "cursor",
+        ],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "list_divisions",
+            description: "Browse the statutory hierarchy.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.list_divisionsInput,
+            outputSchema: schemas.list_divisionsOutput,
+        }),
+    },
+    {
+        name: "get_section_changes",
+        method: "GET",
+        path: "/api/v1/us/statutes/section/{act_id}/changes",
+        query: ["limit", "sinceId", "beforeId", "changeKind", "order"],
+        pathKeys: ["act_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_section_changes",
+            description: "Get this section's change history.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_section_changesInput,
+            outputSchema: schemas.get_section_changesOutput,
+        }),
+    },
+    {
+        name: "get_section_enactments",
+        method: "GET",
+        path: "/api/v1/us/statutes/section/{act_id}/enactments",
+        query: [],
+        pathKeys: ["act_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_section_enactments",
+            description: "Which acts a state publisher lists against this section.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_section_enactmentsInput,
+            outputSchema: schemas.get_section_enactmentsOutput,
+        }),
+    },
+    {
+        name: "extract_citations",
+        method: "POST",
+        path: "/api/v1/us/statutes/extract-citations",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "extract_citations",
+            description: "Find the citations in a text and resolve each.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.extract_citationsInput,
+            outputSchema: schemas.extract_citationsOutput,
+        }),
+    },
+    {
+        name: "get_citing_sections",
+        method: "GET",
+        path: "/api/v1/us/statutes/section/{act_id}/cited-by",
+        query: ["limit"],
+        pathKeys: ["act_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_citing_sections",
+            description: "Find the sections that cite this one.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_citing_sectionsInput,
+            outputSchema: schemas.get_citing_sectionsOutput,
+        }),
+    },
+    {
+        name: "get_definitions",
+        method: "GET",
+        path: "/api/v1/us/statutes/section/{act_id}/definitions",
+        query: [],
+        pathKeys: ["act_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_definitions",
+            description: "Get the defined terms that govern this section.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_definitionsInput,
+            outputSchema: schemas.get_definitionsOutput,
+        }),
+    },
+    {
+        name: "compare_states",
+        method: "GET",
+        path: "/api/v1/us/statutes/section/{act_id}/cross-state",
+        query: ["limit"],
+        pathKeys: ["act_id"],
+        action: defineProviderAction("vaquill", {
+            name: "compare_states",
+            description: "Compare this provision against other states.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.compare_statesInput,
+            outputSchema: schemas.compare_statesOutput,
+        }),
+    },
+    {
+        name: "get_pricing",
+        method: "GET",
+        path: "/api/v1/api-credits/pricing",
+        query: ["region"],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "get_pricing",
+            description: "Get API credit pricing.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_pricingInput,
+            outputSchema: schemas.get_pricingOutput,
+        }),
+    },
+    {
+        name: "list_boards",
+        method: "GET",
+        path: "/api/v1/boards",
+        query: ["corpusType", "state", "limit", "offset"],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "list_boards",
+            description: "List watchable boards.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.list_boardsInput,
+            outputSchema: schemas.list_boardsOutput,
+        }),
+    },
+    {
+        name: "list_watches",
+        method: "GET",
+        path: "/api/v1/watches",
+        query: ["limit", "offset"],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "list_watches",
+            description: "List your board watches.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.list_watchesInput,
+            outputSchema: schemas.list_watchesOutput,
+        }),
+    },
+    {
+        name: "create_watch",
+        method: "POST",
+        path: "/api/v1/watches",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "create_watch",
+            description: "Create a board watch.",
+            operationType: "write",
+            requiredScopes: [],
+            inputSchema: schemas.create_watchInput,
+            outputSchema: schemas.create_watchOutput,
+        }),
+    },
+    {
+        name: "test_watch",
+        method: "POST",
+        path: "/api/v1/watches/{watch_id}/test",
+        query: [],
+        pathKeys: ["watch_id"],
+        action: defineProviderAction("vaquill", {
+            name: "test_watch",
+            description: "Send a test delivery.",
+            operationType: "write",
+            requiredScopes: [],
+            inputSchema: schemas.test_watchInput,
+            outputSchema: schemas.test_watchOutput,
+        }),
+    },
+    {
+        name: "update_watch",
+        method: "PATCH",
+        path: "/api/v1/watches/{watch_id}",
+        query: [],
+        pathKeys: ["watch_id"],
+        action: defineProviderAction("vaquill", {
+            name: "update_watch",
+            description: "Update a board watch.",
+            operationType: "destructive",
+            requiredScopes: [],
+            inputSchema: schemas.update_watchInput,
+            outputSchema: schemas.update_watchOutput,
+        }),
+    },
+    {
+        name: "delete_watch",
+        method: "DELETE",
+        path: "/api/v1/watches/{watch_id}",
+        query: [],
+        pathKeys: ["watch_id"],
+        action: defineProviderAction("vaquill", {
+            name: "delete_watch",
+            description: "Delete a board watch.",
+            operationType: "destructive",
+            requiredScopes: [],
+            inputSchema: schemas.delete_watchInput,
+            outputSchema: schemas.delete_watchOutput,
+        }),
+    },
+    {
+        name: "get_watch_changes",
+        method: "GET",
+        path: "/api/v1/watches/{watch_id}/changes",
+        query: ["limit", "sinceId", "beforeId", "since", "changeKind", "order"],
+        pathKeys: ["watch_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_watch_changes",
+            description: "List what changed on a watch's source.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_watch_changesInput,
+            outputSchema: schemas.get_watch_changesOutput,
+        }),
+    },
+    {
+        name: "get_watch_diff",
+        method: "GET",
+        path: "/api/v1/watches/{watch_id}/changes/{change_id}/diff",
+        query: [],
+        pathKeys: ["watch_id", "change_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_watch_diff",
+            description: "Old-vs-new text for one change.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_watch_diffInput,
+            outputSchema: schemas.get_watch_diffOutput,
+        }),
+    },
+    {
+        name: "get_watch_deliveries",
+        method: "GET",
+        path: "/api/v1/watches/{watch_id}/deliveries",
+        query: ["limit"],
+        pathKeys: ["watch_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_watch_deliveries",
+            description: "List delivery history for a watch.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_watch_deliveriesInput,
+            outputSchema: schemas.get_watch_deliveriesOutput,
+        }),
+    },
+    {
+        name: "get_balance",
+        method: "GET",
+        path: "/api/v1/credits/balance",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "get_balance",
+            description: "Get your credit balance.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_balanceInput,
+            outputSchema: schemas.get_balanceOutput,
+        }),
+    },
+    {
+        name: "get_session_law_changes",
+        method: "GET",
+        path: "/api/v1/us/session-laws/changes",
+        query: ["sinceId", "jurisdiction", "limit"],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "get_session_law_changes",
+            description: "Feed of changes to the session-law registry.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_session_law_changesInput,
+            outputSchema: schemas.get_session_law_changesOutput,
+        }),
+    },
+    {
+        name: "get_session_laws",
+        method: "POST",
+        path: "/api/v1/us/session-laws/batch",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "get_session_laws",
+            description: "Get many state session laws at once, by id or citation.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_session_lawsInput,
+            outputSchema: schemas.get_session_lawsOutput,
+        }),
+    },
+    {
+        name: "search_session_laws",
+        method: "POST",
+        path: "/api/v1/us/session-laws/search",
+        query: [],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "search_session_laws",
+            description: "Search the text of state session laws.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.search_session_lawsInput,
+            outputSchema: schemas.search_session_lawsOutput,
+        }),
+    },
+    {
+        name: "list_session_laws",
+        method: "GET",
+        path: "/api/v1/us/session-laws/list",
+        query: [
+            "jurisdiction",
+            "session",
+            "series",
+            "instrumentType",
+            "approvedFrom",
+            "approvedTo",
+            "effectiveFrom",
+            "effectiveTo",
+            "hasText",
+            "textStatus",
+            "isLaw",
+            "enactmentOutcome",
+            "updatedSince",
+            "q",
+            "cursor",
+            "limit",
+        ],
+        pathKeys: [],
+        action: defineProviderAction("vaquill", {
+            name: "list_session_laws",
+            description: "List a state's session laws.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.list_session_lawsInput,
+            outputSchema: schemas.list_session_lawsOutput,
+        }),
+    },
+    {
+        name: "get_session_law_body",
+        method: "GET",
+        path: "/api/v1/us/session-laws/{session_law_id}/body",
+        query: ["cursor", "startChar", "expectTextSha256"],
+        pathKeys: ["session_law_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_session_law_body",
+            description: "Get a state session law's text.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_session_law_bodyInput,
+            outputSchema: schemas.get_session_law_bodyOutput,
+        }),
+    },
+    {
+        name: "get_session_law",
+        method: "GET",
+        path: "/api/v1/us/session-laws/{session_law_id}",
+        query: ["jurisdiction"],
+        pathKeys: ["session_law_id"],
+        action: defineProviderAction("vaquill", {
+            name: "get_session_law",
+            description: "Get a state session law, by id or by citation.",
+            operationType: "read",
+            requiredScopes: [],
+            inputSchema: schemas.get_session_lawInput,
+            outputSchema: schemas.get_session_lawOutput,
+        }),
+    },
+];
+export const vaquillActions = vaquillOperations.map((operation) => operation.action);
+export const vaquillOperationByName = new Map(vaquillOperations.map((operation) => [operation.name, operation]));

package/src/providers/vaquill/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const credentialValidators: CredentialValidators;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/vaquill/executors.js

@@ -0,0 +1,141 @@
+import { optionalRecord, optionalString, looseArray } from "../../core/cast.js";
+import { requiredResponseRecord, isAbortLikeError, runProviderRequest, ProviderRequestError, providerInputError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { vaquillActions } from "./actions.js";
+import { vaquillOperationByName } from "./actions.js";
+const baseUrl = "https://api.vaquill.ai";
+function redactErrorValue(value, secrets) {
+    if (typeof value === "string") {
+        return secrets.reduce((text, secret) => text.replaceAll(secret, "[REDACTED]"), value);
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redactErrorValue(item, secrets));
+    const object = optionalRecord(value);
+    return object
+        ? Object.fromEntries(Object.entries(object).map(([key, item]) => [key, redactErrorValue(item, secrets)]))
+        : value;
+}
+function errorMessage(body) {
+    const object = optionalRecord(body);
+    const detail = optionalString(object?.detail);
+    const nested = optionalRecord(object?.detail);
+    const fields = [...looseArray(object?.errors), ...looseArray(object?.detail)].flatMap((value) => {
+        const field = optionalRecord(value);
+        const message = optionalString(field?.msg);
+        return message ? [`${looseArray(field?.loc).join(".")}: ${message}`] : [];
+    });
+    return ([
+        detail ?? optionalString(nested?.message) ?? optionalString(object?.message),
+        optionalString(object?.reason),
+        ...fields,
+    ]
+        .filter(Boolean)
+        .join(": ") || undefined);
+}
+async function request(name, input, apiKey, fetcher, parentSignal) {
+    const operation = vaquillOperationByName.get(name);
+    if (!operation)
+        throw providerInputError(`Unknown Vaquill action: ${name}`);
+    return runProviderRequest({ label: "Vaquill", signal: parentSignal }, async (signal) => {
+        let path = operation.path;
+        const payload = { ...input };
+        for (const key of operation.pathKeys) {
+            const value = String(payload[key]);
+            if (value === "." || value === ".." || value.includes("/")) {
+                throw providerInputError(`${key} must be a single path segment; resolve citations containing slashes first`);
+            }
+            path = path.replace(`{${key}}`, encodeURIComponent(value));
+            delete payload[key];
+        }
+        const url = new URL(path, baseUrl);
+        for (const key of operation.query) {
+            const value = payload[key];
+            if (value == null)
+                continue;
+            for (const item of Array.isArray(value) ? value : [value]) {
+                url.searchParams.append(key, String(item));
+            }
+        }
+        const response = await fetcher(url, {
+            method: operation.method,
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+            body: operation.method === "POST" || operation.method === "PATCH" ? JSON.stringify(payload) : undefined,
+            signal,
+        });
+        if (response.status === 204 && name === "delete_watch")
+            return { deleted: true };
+        const body = await response.json().catch((error) => {
+            if (isAbortLikeError(error))
+                throw error;
+            return undefined;
+        });
+        if (!response.ok) {
+            const upstream = optionalRecord(body);
+            const recovery = Object.fromEntries([
+                "actId",
+                "sessionLawId",
+                "reason",
+                "didYouMean",
+                "defaultSessionLawId",
+                "jurisdictions",
+                "candidateCount",
+                "truncated",
+                "sessionCoverage",
+            ]
+                .filter((key) => upstream?.[key] !== undefined)
+                .map((key) => [key, upstream?.[key]]));
+            const auth = optionalRecord(input.webhookAuth);
+            const secrets = [apiKey, optionalString(input.webhookSecret), optionalString(auth?.secret)].filter((secret) => Boolean(secret));
+            const message = optionalString(redactErrorValue(errorMessage(body), secrets));
+            const data = Object.keys(recovery).length ? redactErrorValue(recovery, secrets) : undefined;
+            throw new ProviderRequestError(response.status, `Vaquill request failed (${response.status})${message ? `: ${message}` : ""}`, data, "provider_error");
+        }
+        return requiredResponseRecord(body, "Vaquill response");
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const operation = vaquillOperationByName.get(actionName);
+    if (!operation)
+        throw providerInputError(`Unknown Vaquill action: ${actionName}`);
+    const normalized = { ...values };
+    for (const key of ["state", "jurisdiction"]) {
+        const value = normalized[key];
+        if (typeof value === "string")
+            normalized[key] = value.toLowerCase();
+        else if (Array.isArray(value))
+            normalized[key] = value.map((item) => (typeof item === "string" ? item.toLowerCase() : item));
+    }
+    if (actionName === "list_divisions" && typeof normalized.corpusType === "string") {
+        normalized.corpusType = normalized.corpusType.toUpperCase();
+    }
+    const payload = normalized;
+    if (actionName === "create_watch") {
+        const channel = payload.channel ?? "webhook";
+        if (channel !== "email" && !optionalString(payload.webhookUrl)?.trim()) {
+            throw providerInputError("webhookUrl is required for webhook and both channels");
+        }
+        if (channel !== "webhook" && !optionalString(payload.emailAddress)?.trim()) {
+            throw providerInputError("emailAddress is required for email and both channels");
+        }
+    }
+    return request(actionName, payload, apiKey, fetcher, context.signal);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request("get_balance", {}, input.apiKey, fetcher, signal);
+        return { profile: { displayName: "Vaquill API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("vaquill", Object.fromEntries(vaquillActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "vaquill",
+    baseUrl: baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});