@zackbart/connecta 0.35.0 → 0.36.1

package/dist/providers/quickbooks/tools.js

@@ -0,0 +1,117 @@
+import { quickbooksWrites } from "./lib/writes.js";
+import { Effect, Schema } from "effect";
+import { ConnectorCallError } from "../../errors.js";
+import { Refusal } from "../../http/errors.js";
+import { get as getTool, list } from "../../http/tools.js";
+import { companyInfo, ENTITIES, queryRecords, REPORTS, recordReads, reportReads } from "./api.js";
+import { CompanyShape, namedRecord, NamedRecordShape, object, ReportShape } from "./safety.js";
+import { buildSearch, Filters, matches, reportParameters, reportProblem, REPORT_QUERY } from "./lib/query.js";
+const Entity = Schema.Literals([
+    "customers",
+    "vendors",
+    "accounts",
+    "items",
+    "invoices",
+    "bills",
+    "payments",
+    "bill_payments",
+]);
+const Id = Schema.String.check(matches("^[1-9]\\d{0,30}$"));
+const query = { minorversion: "75" };
+const checked = (run) => Effect.try({
+    try: run,
+    catch: (error) => new Refusal({
+        error: error instanceof ConnectorCallError
+            ? error
+            : new ConnectorCallError("invalid_args", "Invalid QuickBooks arguments."),
+    }),
+});
+export function quickbooksTools({ connection, pageSize, options, }) {
+    return [
+        ...quickbooksWrites(connection, options.realmId),
+        getTool(connection, {
+            name: "get_company_info",
+            description: "Read the configured company's accounting identity without contact or tax identifiers.",
+            input: Schema.Struct({}),
+            output: CompanyShape,
+            fields: true,
+            run: () => connection
+                .send(companyInfo, { params: { id: options.realmId }, query })
+                .pipe(Effect.map(({ data }) => object(object(data)["CompanyInfo"]))),
+        }),
+        list(connection, {
+            name: "search_records",
+            description: "Search reviewed accounting records using bounded structured filters. Customer/vendor names are exact DisplayName matches; record ids and references join invoices, bills and accounting payments. No raw SQL. Inactive master records need an explicit Active filter.",
+            filters: {
+                entity: Entity.annotate({
+                    description: "Accounting record family; payments are accounting records, not the Payments API.",
+                }),
+                filters: Schema.optionalKey(Filters.annotate({
+                    description: "At most 8 AND filters. Master records: Id, Active, LastUpdatedTime and DisplayName (customers/vendors) or Name (accounts/items). Transactions: Id, LastUpdatedTime, TxnDate and CustomerRef or VendorRef. Invoices/bills/bill payments also DocNumber; invoices/bills also DueDate and Balance.",
+                })),
+            },
+            row: NamedRecordShape,
+            limit: {
+                default: pageSize,
+                max: 100,
+                description: "Rows per page, default 25, at most 100. A bounded extra row detects continuation.",
+            },
+            cursor: "bound",
+            cursorScope: { realmId: options.realmId, environment: options.environment },
+            page: (args, cursor) => Effect.gen(function* () {
+                const entity = ENTITIES[args.entity];
+                const start = cursor === undefined ? 1 : Number(cursor);
+                const sql = yield* checked(() => buildSearch(entity, args.filters ?? [], start, args.limit + 1));
+                const { data } = yield* connection.send(queryRecords, { query: { ...query, query: sql } }, { flags: { [entity]: true } });
+                const rows = object(object(data)["QueryResponse"])[entity];
+                const all = Array.isArray(rows) ? rows : [];
+                const more = all.length > args.limit;
+                return {
+                    rows: all.slice(0, args.limit).map(namedRecord),
+                    page: { hasMore: more, nextCursor: more ? String(start + args.limit) : null },
+                };
+            }),
+        }),
+        getTool(connection, {
+            name: "get_record",
+            description: "Read one reviewed accounting record by Id. SyncToken is its public version identifier; DocNumber is a separate human label. Contact details and payment credentials are withheld.",
+            input: Schema.Struct({
+                entity: Entity,
+                id: Id.annotate({ description: "Record Id from search_records, never DocNumber." }),
+            }),
+            output: NamedRecordShape,
+            fields: true,
+            run: (args) => connection
+                .sendPath({
+                method: "GET",
+                path: `/${ENTITIES[args.entity].toLowerCase()}/${args.id}`,
+                template: recordReads[args.entity].path,
+                query: [["minorversion", "75"]],
+            })
+                .pipe(Effect.map(({ data }) => namedRecord(object(data)[ENTITIES[args.entity]]))),
+        }),
+        getTool(connection, {
+            name: "get_report",
+            description: "Read Profit & Loss, Balance Sheet, Cash Flow or AR/AP aging summary. Preserve Header, Columns and nested Rows; empty amount strings mean no value, never zero. P&L/CashFlow support start_date; P&L/BalanceSheet support accounting_method. All accept end_date (aging as-of date). Reports retain vendor currency; no currency conversion.",
+            input: Schema.Struct({ report: Schema.Literals(REPORTS), ...REPORT_QUERY }),
+            output: ReportShape,
+            fields: true,
+            run: (args) => Effect.gen(function* () {
+                const { report, ...raw } = args;
+                const parameters = reportParameters(report, Object.fromEntries(Object.entries(raw).filter(([, value]) => value !== undefined)));
+                yield* checked(() => {
+                    const problem = reportProblem(report, parameters);
+                    if (problem)
+                        throw new ConnectorCallError("invalid_args", problem);
+                });
+                const { data } = yield* connection.sendPath({
+                    method: "GET",
+                    path: `/reports/${report}`,
+                    template: reportReads[report].path,
+                    query: Object.entries({ ...parameters, minorversion: "75" }),
+                });
+                return object(data);
+            }),
+        }),
+    ];
+}

package/dist/providers/sheets/api.js

@@ -15,7 +15,7 @@ export const SHEETS = {
 };
 const SpreadsheetId = { spreadsheetId: Schema.String };
 const optionalString = Schema.optionalKey(Schema.String);
-export const getSpreadsheet = get("getSpreadsheet", "/spreadsheets/:spreadsheetId", {
+const getSpreadsheet = get("getSpreadsheet", "/spreadsheets/:spreadsheetId", {
     params: SpreadsheetId,
     query: { includeGridData: optionalString, fields: optionalString },
     success: Schema.Unknown,

package/dist/providers/sheets/lib/hatch.js

@@ -23,7 +23,7 @@ export const sheetsIndex = new OperationIndex(sheetsDiscovery, {
     pathMatching: "uri-template",
 });
 /** Decode range colons only. Encoded actions, ids and unreserved bytes still fail the shared backstop. */
-export function sheetsPath(path) {
+function sheetsPath(path) {
     const match = /^(\/spreadsheets\/[A-Za-z0-9_-]+\/values\/)([^/?#]+)$/.exec(path);
     if (!match)
         return path;
@@ -37,7 +37,7 @@ export function sheetsPath(path) {
 }
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 /** Same scalar, range and write-cell ceilings as the named workflows, including filter-selected writes. */
-export function sheetsRequestProblem(call) {
+function sheetsRequestProblem(call) {
     const body = record(call.body);
     if (call.op.path === "/spreadsheets/{spreadsheetId}:batchUpdate") {
         const requests = body["requests"];

package/dist/providers/sheets/lib/requests.js

@@ -1,4 +1,4 @@
-export const SHEETS_REQUEST_KINDS = [
+const SHEETS_REQUEST_KINDS = [
     "addBanding",
     "addChart",
     "addCommentReply",

package/dist/providers/sheets/tools.js

@@ -5,7 +5,6 @@ import { Refusal } from "../../http/errors.js";
 import { googleClient, googleFailureMessage, googleOutcomeOf } from "../_shared/google/kit.js";
 import { clampText, jsonBytes, RESULT_BUDGET_BYTES } from "../_shared/google/result-size.js";
 import { encodeForAgent, redactBeforeCut } from "../../sent-secrets.js";
-import { SHEETS } from "./api.js";
 import { read, write } from "../../http/tools.js";
 import { boundCursor } from "../../http/paging.js";
 import { fieldsInput, fieldsProblem, selectFields } from "../../http/fields.js";
@@ -336,7 +335,7 @@ const SPREADSHEET_FIELDS = [
 ].join(",");
 // --- Tools ------------------------------------------------------------------------
 export function sheetsTools({ connection }) {
-    const client = googleClient(connection, SHEETS.provider, { standard: true, index: sheetsIndex });
+    const client = googleClient(connection, sheetsIndex);
     const readOnly = { readOnlyHint: true };
     // Additive: nothing that existed is lost. Writes require a writable
     // endpoint: call_destructive_tool or a program. The host controls approval.

package/dist/providers/slides/api.js

@@ -23,7 +23,7 @@ const ReadQuery = {
     commentsViewMode: Schema.optionalKey(Schema.String),
 };
 // Discovery calls this one parameter `presentationsId` (plural).
-export const getPresentation = get("getPresentation", "/presentations/:presentationsId", {
+const getPresentation = get("getPresentation", "/presentations/:presentationsId", {
     params: { presentationsId: Schema.String },
     query: ReadQuery,
     success: Schema.Unknown,

package/dist/providers/slides/tools.js

@@ -5,7 +5,7 @@ import { RESULT_BUDGET_BYTES, clampRedactedText, clampText, jsonBytes } from "..
 import { googleClient, googleOutcomeOf, googleFailureMessage } from "../_shared/google/kit.js";
 import { encodeForAgent, redactBeforeCut, redactSentSecrets } from "../../sent-secrets.js";
 import { REQUEST_KINDS, COMMENT_KINDS, COMMENTS_UNSAVED } from "./lib/requests.js";
-import { SLIDES, SLIDES_INDEX } from "./api.js";
+import { SLIDES_INDEX } from "./api.js";
 import * as contracts from "./lib/schemas.js";
 import { read, write } from "../../http/tools.js";
 import { Operation } from "../../runtime/call.js";
@@ -1228,7 +1228,7 @@ function postToThread(connection, client, ctx, tool, args, post) {
     });
 }
 export function slidesTools({ connection }) {
-    const client = googleClient(connection, SLIDES.provider, { standard: true, index: SLIDES_INDEX });
+    const client = googleClient(connection, SLIDES_INDEX);
     const readOnly = { readOnlyHint: true };
     const presentationPath = (id) => `/presentations/${encodeURIComponent(id)}`;
     const nextPage = (cursor) => cursor === null ? { hasMore: false } : { hasMore: true, nextCursor: cursor };

package/dist/providers/stripe/api.js

@@ -115,7 +115,7 @@ export const READ_CAP_MS = 60_000;
  * /v1/tax/calculations` is deliberately absent: it persists a Calculation
  * object a later Tax Transaction can reference, and Stripe bills each call.
  */
-export const READ_POSTS = [
+const READ_POSTS = [
     ["POST", "/v1/invoices/create_preview", "Computes an upcoming invoice; Stripe persists nothing."],
 ];
 function invalid(message) {
@@ -126,7 +126,7 @@ function invalid(message) {
  * The key's own prefix carries its mode, so a live key in a sandbox
  * connector (or the reverse) is refused before any request leaves.
  */
-export function stripeKeyProblem(key, mode) {
+function stripeKeyProblem(key, mode) {
     if (/^(?:sk|rk)_org_/.test(key)) {
         return "This is a Stripe organization key, which needs a Stripe-Context header this connector does not send. Use one account's secret or restricted key.";
     }
@@ -213,7 +213,7 @@ function expansions(call) {
  * secret's value, or a full Issuing card number or CVC, which an Issuing
  * authorization, transaction, or token can embed as well as the card itself.
  */
-export function refuse(call) {
+function refuse(call) {
     const expanded = expansions(call);
     if (/^\/v1\/apps\/secrets(?:\/|$)/.test(call.path) && expanded.some((path) => /(?:^|\.)payload$/.test(path))) {
         return "Stripe Apps secret values are not returned through Connecta. Read the secret's metadata without expanding payload.";
@@ -225,7 +225,7 @@ export function refuse(call) {
     return undefined;
 }
 export const stripeIndex = new OperationIndex(openapi, { vendor: "stripe", title: "Stripe" });
-export const stripeSafety = valueSafety(STRIPE_VALUE_SAFETY, () => stripeIndex);
+const stripeSafety = valueSafety(STRIPE_VALUE_SAFETY, () => stripeIndex);
 function operationRefusal(op) {
     return (checkServer(op.server) ??
         stripeSafety.refusal(op.method, op.path) ??
@@ -268,11 +268,11 @@ export const safety = () => ({
     reviewed: restSafety(stripeSafety, stripeIndex),
     sensitiveFields: { names: [], choice: "drop" },
 });
-export const getAccount = get("getAccount", "/v1/account", {
+const getAccount = get("getAccount", "/v1/account", {
     headers: Schema.Struct({ "Stripe-Account": Schema.optionalKey(Schema.String) }),
     success: Schema.Unknown,
 });
-export const getBalance = get("getBalance", "/v1/balance", { success: Schema.Unknown });
+const getBalance = get("getBalance", "/v1/balance", { success: Schema.Unknown });
 const RESPONSE_MEDIA = { "GET /v1/quotes/{quote}/pdf": ["application/pdf"] };
 export const StripeApi = {
     ...indexedVendor("stripe", stripeIndex, [getAccount, getBalance]),
@@ -317,7 +317,7 @@ export function connectedAccount(options) {
         throw new Error('stripe() connectedAccount must be a Stripe account id ("acct_...").');
     return account;
 }
-export function checkServer(server) {
+function checkServer(server) {
     if (server === undefined || server === FILES_ORIGIN)
         return undefined;
     return server === METER_EVENTS_ORIGIN

package/dist/providers/tithely/api.js

@@ -162,7 +162,7 @@ export const listOrganizations = get("listOrganizations", "/organizations-list",
     query: PageQuery,
     success: Rows(OrganizationRecord),
 }).annotate(Summary, "List all organizations these keys manage");
-export const getOrganization = get("getOrganization", "/organizations/:organization_id", {
+const getOrganization = get("getOrganization", "/organizations/:organization_id", {
     params: id("organization_id"),
     success: Single("organization_id", OrganizationRecord),
 }).annotate(Summary, "Retrieve an organization");
@@ -174,7 +174,7 @@ export const listAllAccounts = get("listAllAccounts", "/accounts-list-all", {
     query: PageQuery,
     success: Rows(AccountRecord),
 }).annotate(Summary, "List all donor accounts");
-export const getAccount = get("getAccount", "/accounts/:account_id", {
+const getAccount = get("getAccount", "/accounts/:account_id", {
     params: id("account_id"),
     success: Single("account_id", AccountRecord),
 }).annotate(Summary, "Retrieve a donor account");

package/dist/providers/vercel/api.js

@@ -17,7 +17,7 @@ import { pinAdmission, pinOptions, pinQuery, pinRoute, readPinnedTeam } from "./
 export const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
 export const READ_CAP_MS = 60_000;
 /** POSTs that only read, admitted by `vercel_api_read`. */
-export const READ_POSTS = [
+const READ_POSTS = [
     ["POST", "/v2/observability/query", "Runs an Observability metrics query; Vercel persists nothing."],
     ["POST", "/v1/registrar/domains/availability", "Checks availability for a list of domains; buys nothing."],
     ["POST", "/v1/registrar/domains/price", "Quotes registrar prices for a list of domains; buys nothing."],
@@ -39,7 +39,7 @@ export function invalid(message) {
 export function compact(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
-export function truthy(value) {
+function truthy(value) {
     return value === true || value === 1 || (typeof value === "string" && /^(?:1|true)$/i.test(value.trim()));
 }
 /**
@@ -155,34 +155,34 @@ class VercelIndex extends OperationIndex {
     }
 }
 export const vercelIndex = new VercelIndex(discoveryIndex(openapi), { vendor: "vercel", title: "Vercel" });
-export const vercelSafety = valueSafety(VERCEL_VALUE_SAFETY, () => vercelIndex);
+const vercelSafety = valueSafety(VERCEL_VALUE_SAFETY, () => vercelIndex);
 const Query = Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Array(Schema.String)]));
 const params = (...names) => Schema.Struct(Object.fromEntries(names.map((name) => [name, Schema.String])));
-export const currentUser = get("currentUser", "/v2/user", { success: Schema.Unknown });
-export const teams = get("teams", "/v2/teams", { query: Query, success: Schema.Unknown });
-export const projectEnv = get("projectEnv", "/v10/projects/:idOrName/env", {
+const currentUser = get("currentUser", "/v2/user", { success: Schema.Unknown });
+const teams = get("teams", "/v2/teams", { query: Query, success: Schema.Unknown });
+const projectEnv = get("projectEnv", "/v10/projects/:idOrName/env", {
     params: params("idOrName"),
     query: Query,
     success: Schema.Unknown,
 });
-export const upsertEnv = post("upsertEnv", "/v10/projects/:idOrName/env", {
+const upsertEnv = post("upsertEnv", "/v10/projects/:idOrName/env", {
     params: params("idOrName"),
     query: Query,
     payload: Schema.Unknown,
     success: Schema.Unknown,
 });
-export const updateEnv = patch("updateEnv", "/v9/projects/:idOrName/env/:id", {
+const updateEnv = patch("updateEnv", "/v9/projects/:idOrName/env/:id", {
     params: params("idOrName", "id"),
     query: Query,
     payload: Schema.Unknown,
     success: Schema.Unknown,
 });
-export const buildLogs = get("buildLogs", "/v3/deployments/:idOrUrl/events", {
+const buildLogs = get("buildLogs", "/v3/deployments/:idOrUrl/events", {
     params: params("idOrUrl"),
     query: Query,
     success: Schema.Unknown,
 });
-export const runtimeLogs = get("runtimeLogs", "/v1/projects/:projectId/deployments/:deploymentId/runtime-logs", {
+const runtimeLogs = get("runtimeLogs", "/v1/projects/:projectId/deployments/:deploymentId/runtime-logs", {
     params: params("projectId", "deploymentId"),
     query: Query,
     success: Schema.Unknown,
@@ -294,7 +294,7 @@ export const refuse = (call) => {
     }
     return undefined;
 };
-export function scope(call, teamId, pin) {
+function scope(call, teamId, pin) {
     if (pin)
         return { ...call, query: pinQuery(vercelIndex, call, pin) };
     const query = { ...call.query };
@@ -374,7 +374,7 @@ export function queryOf(call) {
 export function queryPairs(call) {
     return Object.entries(queryOf(call)).flatMap(([key, value]) => (Array.isArray(value) ? value : [value]).map((value) => [key, value]));
 }
-export function sendVercel(connection, call, options, sendOptions) {
+function sendVercel(connection, call, options, sendOptions) {
     return checked(() => {
         const server = checkServer(call.op.server);
         if (server)

package/dist/providers/vercel/index.js

@@ -1,7 +1,6 @@
 import { keys, optionsOf, variants } from "../../config-schema.js";
 import { defineApiProvider } from "../../http/provider.js";
 import { CALL_ADMISSION } from "../../provider.js";
-import { removedHostedMcp } from "../_shared/rest/dispatch.js";
 import { authenticate, MAX_RESPONSE_BYTES, READ_CAP_MS, probe, result, safety, vercelErrors, VercelApi, usageGuide, transformGuide, VERCEL_VERDICTS, VERCEL_PAGES, vercelBinding, vercelIndex, } from "./api.js";
 import { VERCEL_API_BASE_URL } from "./lib/config.js";
 import { pinOptions, PIN_WRITE_STEPS } from "./lib/pin.js";
@@ -38,7 +37,7 @@ export const vercel = defineApiProvider({
     vendor: VercelApi,
     baseUrl: (options) => {
         if (options.auth.type !== "token")
-            removedHostedMcp();
+            throw new Error("remoteMcp() with ConnectaConfig.classification for hosted MCP connections; use a distinct id beside the API connector.");
         pinOptions(options);
         return options.baseUrl ?? VERCEL_API_BASE_URL;
     },

package/dist/providers/vercel/lib/pin.js

@@ -34,7 +34,7 @@ const object = (value) => value !== null && typeof value === "object" && !Array.
 const fail = (reason) => {
     throw new ConnectorCallError("provider_permission_denied", `Vercel team pin: ${reason} Not sent to the requested resource.`, { retryable: false });
 };
-export function validatePin(options) {
+function validatePin(options) {
     if (options.pin === undefined)
         return;
     const id = options.pin?.teamId;

package/dist/routes/mcp.js

@@ -268,7 +268,7 @@ function scopedToBody(handler, signal) {
  * The request's admission permit, owned by its Scope.
  *
  * Admission goes through the controller's Promise rather than its Effect
- * program (`acquireScoped`), on purpose. The pool is shared by every request
+ * program, on purpose. The pool is shared by every request
  * in the isolate, and a queued request is handed its permit from inside the
  * request whose body just ended. A fiber resumed there would authorize and
  * serve this request in that one's I/O context, which workerd refuses;

package/dist/routes/oauth.js

@@ -217,6 +217,9 @@ async function finishOAuthCallback(context) {
         if (["state", "iss", "code", "error"].some((name) => url.searchParams.getAll(name).length > 1))
             return refused();
         try {
+            if (connector.verifyCallbackParameters &&
+                !(await connector.verifyCallbackParameters(url.searchParams, connectorContext)))
+                return refused();
             const issuer = url.searchParams.get("iss");
             if (connector.verifyCallbackIssuer) {
                 if (!(await connector.verifyCallbackIssuer(issuer, connectorContext)))

package/dist/runtime/admission.js

@@ -7,7 +7,6 @@
 // read its private bookkeeping, and one that emits nothing into the `.d.ts`.
 // Promise callers keep `acquire()`, which runs the same program through
 // runEdge; Effect callers come through this module and never see a Promise.
-import { Effect } from "effect";
 let program;
 /**
  * Install the controller's admission program. Called once, by
@@ -32,14 +31,3 @@ export function admit(controller, options = {}) {
     }
     return program(controller, options.signal, options.wait !== false);
 }
-/**
- * A lease owned by the enclosing Scope: released when the scope closes, on
- * success, failure, or interruption alike. The wait itself stays
- * interruptible — a queued request whose caller left must not hold its place
- * in line until the queue timeout.
- */
-export function acquireScoped(controller, options = {}) {
-    return Effect.acquireRelease(admit(controller, options), (lease) => Effect.sync(() => lease.release()), {
-        interruptible: true,
-    });
-}

package/dist/runtime/call.js

@@ -292,9 +292,6 @@ export function deriveView(view, overrides) {
     views.set(derived, entry);
     return derived;
 }
-export function viewCaller(view) {
-    return serviceFor(view, Caller);
-}
 export function viewLease(view) {
     return views.get(view)?.call;
 }
@@ -337,7 +334,6 @@ export function contextView(lease, operation) {
         lease.close();
     return view;
 }
-export const callView = (operation, lease) => contextView(lease, operation);
 export function chargeView(view) {
     const budget = recordedService(view, Budget);
     return budget ? runEdge(budget.charge) : Promise.reject(ended());

package/dist/skills.js

@@ -32,7 +32,6 @@ export function endpointInstructions(description, native) {
 export function nativeInstructions(executeCode) {
     return `Each tool here is one operation; annotations classify reads/writes. Call known tools directly; ${executeCode ? "combine work in execute_code using the program addresses in tool descriptions." : "find tools with your host's search."} Read-only endpoints omit and refuse writes. Never repeat a write for output. Give auth handoffs to the user/operator. Follow nextAction to page with ${executeCode ? "connecta.result in execute_code" : "read_result"}. skills lists guidance.`;
 }
-export { USAGE_SKILL } from "./usage-guide.js";
 /** True when at least one of `connectors` carries a usage guide. */
 export function hasConnectorGuides(connectors) {
     return connectors.some((connector) => connectorGuide(connector) !== undefined);

package/dist/storage/keys.js

@@ -2,9 +2,8 @@
 //
 // A deployment has one KVStorage (D1 on Workers, SQLite on Node, memory in
 // tests), and every subsystem shares it. Sharing is safe because no two
-// families claim overlapping keys, and that is only checkable if every key is
-// built here: `test/storage-keys.node.test.ts` fails when another source file
-// spells one of these prefixes itself.
+// families claim overlapping keys. Build every key here; persistence journeys
+// check actual isolation through the deployment and its physical database.
 //
 // Each family records:
 //

package/dist/types.d.ts

@@ -432,6 +432,8 @@ export interface Connector {
      * pending URL could complete consent with their own account.
      */
     verifyState?(state: string | null, ctx: ConnectorContext): Promise<boolean>;
+    /** Validate provider callback parameters after state verification and before issuer validation, including errors. */
+    verifyCallbackParameters?(params: URLSearchParams, ctx: ConnectorContext): Promise<boolean>;
     /** Validate a callback issuer against its verified consent, including error responses. */
     verifyCallbackIssuer?(issuer: string | null, ctx: ConnectorContext): Promise<boolean>;
     /**

package/dist/ui.d.ts

@@ -6,7 +6,7 @@ import type { RegistryView } from "./registry.js";
 import type { ConnectaBranding, Connector, ConnectorStatus, ToolDef, UiAuthConfig } from "./types.js";
 export { filterUiConnectors, type CredentialManagementCapability, type UiConnector, type UiData, } from "./operator-ui/model.js";
 export { CONNECTA_FAVICON_SVG, resolveBranding, isSafeHttpUrl, isSafeHttpsUrl, isSafeIconHref } from "./branding.js";
-export type OperatorPage = import("./operator-ui/view.js").OperatorPage;
+export type OperatorPage = import("./operator-ui/contract.js").OperatorPage;
 export declare function operatorPageForPath(path: string): OperatorPage | undefined;
 export declare function operatorPageTitle(page: OperatorPage, configuredTitle: string): string;
 /** Report the verdict the registry stored, independent of whether an endpoint is read-only. */

package/dist/ui.js

@@ -164,7 +164,6 @@ _nonce, page = "endpoints") {
             productName: brand.productName,
             brandMark: brandMark(branding, true),
             productDescription: brand.description,
-            productOperatorLabel: brand.productName + " operator",
         })}</script><script defer src="${OPERATOR_UI_SCRIPT_PATH}"></script>`,
     });
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CONNECTA_VERSION = "0.35.0";
+export declare const CONNECTA_VERSION = "0.36.1";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated from package.json by scripts/generate-version.mjs.
 // Workers-safe: no runtime filesystem read or deployment override.
-export const CONNECTA_VERSION = "0.35.0";
+export const CONNECTA_VERSION = "0.36.1";

package/documentation/README.md

@@ -12,6 +12,7 @@ For a new deployment, start with [Deploying Connecta](./deploying.md).
 | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
 | Add or remove a connector                | [Change the connector roster](./integrating.md#add-or-remove-a-connector)                                                           |
 | Set up a maintained provider             | [Maintained provider setup](./providers.md)                                                                                         |
+| Inspect maintained API sources and tools | [API sources and tool inventory](./providers.md#api-sources-and-tool-inventory)                                                     |
 | Organize an agent's pools and tiers      | [Organizing an agent's pools](./auth.md#organizing-an-agents-pools)                                                                 |
 | Add a person (maintainer or pool member) | [Add a person](./auth.md#add-a-person), [member page](./operator-ui.md#use-the-member-page)                                         |
 | Connect a shared credential              | [Connect a shared credential](./auth.md#connect-a-shared-credential)                                                                |