@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/youzan/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent, toProviderExecutionError, } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, toProviderExecutionError, providerInputError, } from "../provider-runtime.js";
 export const youzanApiBaseUrl = "https://open.youzanyun.com";
 const youzanTokenUrl = `${youzanApiBaseUrl}/auth/token`;
 export async function validateYouzanCredential(values, fetcher, signal) {
@@ -22,10 +22,10 @@ export function resolveYouzanCredential(input) {
     const clientSecret = optionalString(input.clientSecret);
     const grantId = optionalString(input.grantId);
     if (!clientId || !clientSecret || !grantId) {
-        throw new ProviderRequestError(400, "youzan clientId, clientSecret, and grantId are required");
+        throw providerInputError("youzan clientId, clientSecret, and grantId are required");
     }
     if ([...grantId].some((character) => character < "0" || character > "9")) {
-        throw new ProviderRequestError(400, "youzan grantId must contain only digits");
+        throw providerInputError("youzan grantId must contain only digits");
     }
     return { clientId, clientSecret, grantId };
 }
@@ -202,7 +202,7 @@ export const youzanActionHandlers = {
 function validatePageWindow(input, defaultPageSize, maximum) {
     const page = optionalInteger(input.page) ?? 1;
     if (page * (optionalInteger(input.pageSize) ?? defaultPageSize) > maximum) {
-        throw new ProviderRequestError(400, `page multiplied by pageSize cannot exceed ${maximum}`);
+        throw providerInputError(`page multiplied by pageSize cannot exceed ${maximum}`);
     }
 }
 function validateOrderTimePairs(input) {
@@ -212,7 +212,7 @@ function validateOrderTimePairs(input) {
         ["completedAfter", "completedBefore"],
     ]) {
         if ((input[after] !== undefined) !== (input[before] !== undefined)) {
-            throw new ProviderRequestError(400, `${after} and ${before} must be provided together`);
+            throw providerInputError(`${after} and ${before} must be provided together`);
         }
     }
 }
@@ -233,7 +233,7 @@ async function requestYouzanApi(api, version, body, context) {
         throw createYouzanApiError(response.status, payload);
     }
     if (payload.data === undefined || payload.data === null) {
-        throw youzanError("provider_error", "Youzan returned an invalid data payload", 502);
+        throw new ProviderRequestError(502, "Youzan returned an invalid data payload", undefined, "provider_error");
     }
     return payload.data;
 }
@@ -249,19 +249,19 @@ async function fetchYouzanJson(url, init, fetcher, parentSignal) {
             parsed = JSON.parse(text);
         }
         catch {
-            throw youzanError("provider_error", "Youzan returned invalid JSON", 502);
+            throw new ProviderRequestError(502, "Youzan returned invalid JSON", undefined, "provider_error");
         }
         const payload = optionalRecord(parsed);
         if (!payload)
-            throw youzanError("provider_error", "Youzan returned invalid JSON", 502);
+            throw new ProviderRequestError(502, "Youzan returned invalid JSON", undefined, "provider_error");
         return { response, payload };
     }
     catch (error) {
         if (error instanceof ProviderRequestError)
             throw error;
         if (timeout.didTimeout())
-            throw youzanError("provider_error", "Youzan request timed out", 504);
-        throw youzanError("provider_error", error instanceof Error ? `Youzan request failed: ${error.message}` : "Youzan request failed", 502);
+            throw new ProviderRequestError(504, "Youzan request timed out", undefined, "provider_error");
+        throw new ProviderRequestError(502, error instanceof Error ? `Youzan request failed: ${error.message}` : "Youzan request failed", undefined, "provider_error");
     }
     finally {
         timeout.cleanup();
@@ -270,21 +270,21 @@ async function fetchYouzanJson(url, init, fetcher, parentSignal) {
 function createYouzanTokenError(status, payload, phase) {
     const message = readYouzanMessage(payload, "Youzan rejected the application credentials");
     if (status === 429)
-        return youzanError("rate_limited", message, 429, payload);
+        return new ProviderRequestError(429, message, payload, "rate_limited");
     if (status >= 500)
-        return youzanError("provider_error", message, 502, payload);
+        return new ProviderRequestError(502, message, payload, "provider_error");
     return phase === "validate"
-        ? youzanError("invalid_input", message, 400, payload)
-        : youzanError("authorization_failed", message, 401, payload);
+        ? new ProviderRequestError(400, message, payload, "invalid_input")
+        : new ProviderRequestError(401, message, payload, "authorization_failed");
 }
 function createYouzanApiError(status, payload) {
     const message = readYouzanMessage(payload, "Youzan API request failed");
     if (status === 429)
-        return youzanError("rate_limited", message, 429, payload);
+        return new ProviderRequestError(429, message, payload, "rate_limited");
     if (status === 401 || status === 403 || payload.code === 40010) {
-        return youzanError("authorization_failed", message, 401, payload);
+        return new ProviderRequestError(401, message, payload, "authorization_failed");
     }
-    return youzanError("provider_error", message, 502, payload);
+    return new ProviderRequestError(502, message, payload, "provider_error");
 }
 function readYouzanMessage(payload, fallback) {
     return optionalString(payload.message) ?? optionalString(payload.msg) ?? fallback;
@@ -292,24 +292,21 @@ function readYouzanMessage(payload, fallback) {
 function requireObject(value, label) {
     const object = optionalRecord(value);
     if (!object)
-        throw youzanError("provider_error", `${label} payload is invalid`, 502);
+        throw new ProviderRequestError(502, `${label} payload is invalid`, undefined, "provider_error");
     return object;
 }
 function requireObjectArray(value, label) {
     if (!Array.isArray(value))
-        throw youzanError("provider_error", `${label} payload is invalid`, 502);
+        throw new ProviderRequestError(502, `${label} payload is invalid`, undefined, "provider_error");
     const objects = value.map(optionalRecord);
     if (objects.some((item) => item === undefined)) {
-        throw youzanError("provider_error", `${label} payload is invalid`, 502);
+        throw new ProviderRequestError(502, `${label} payload is invalid`, undefined, "provider_error");
     }
     return objects;
 }
 function requireNonNegativeInteger(value, label) {
     if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-        throw youzanError("provider_error", `${label} payload is invalid`, 502);
+        throw new ProviderRequestError(502, `${label} payload is invalid`, undefined, "provider_error");
     }
     return value;
 }
-function youzanError(code, message, status, details) {
-    return new ProviderRequestError(status, message, details, code);
-}

package/src/providers/zenkit/runtime.js

@@ -1,4 +1,4 @@
-import { optionalRecord, optionalString } from "../../core/cast.js";
+import { booleanString, optionalRecord, optionalString } from "../../core/cast.js";
 import { ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
 export const zenkitApiBaseUrl = "https://base.zenkit.com/api/v1";
 const zenkitValidationPath = "/auth/currentuser";
@@ -57,7 +57,7 @@ async function listWorkspacesAndLists(context) {
         phase: "execute",
     });
     if (!Array.isArray(payload)) {
-        throw providerError("provider_error", "Zenkit workspaces response must be an array", 502);
+        throw new ProviderRequestError(502, "Zenkit workspaces response must be an array", undefined, "provider_error");
     }
     return { workspaces: payload };
 }
@@ -90,10 +90,10 @@ async function searchEntries(input, context) {
             limit: stringifyOptionalNumber(input.limit),
             preferredListIds: stringifyOptionalArray(input.preferredListIds),
             excludeListEntryUUIDs: stringifyOptionalArray(input.excludeEntryUuids),
-            searchInArchive: stringifyOptionalBoolean(input.searchInArchive),
-            includeRelatedLists: stringifyOptionalBoolean(input.includeRelatedLists),
-            includeRelatedWorkspaces: stringifyOptionalBoolean(input.includeRelatedWorkspaces),
-            includeRelatedListElements: stringifyOptionalBoolean(input.includeRelatedListElements),
+            searchInArchive: booleanString(input.searchInArchive),
+            includeRelatedLists: booleanString(input.includeRelatedLists),
+            includeRelatedWorkspaces: booleanString(input.includeRelatedWorkspaces),
+            includeRelatedListElements: booleanString(input.includeRelatedListElements),
         },
     });
     return { results: requiredResponseRecord(payload, "Zenkit entry search response") };
@@ -181,21 +181,21 @@ async function readZenkitPayload(response) {
         if (!response.ok) {
             return { message: text.trim().slice(0, 500) };
         }
-        throw providerError("provider_error", "Zenkit returned invalid JSON", 502);
+        throw new ProviderRequestError(502, "Zenkit returned invalid JSON", undefined, "provider_error");
     }
 }
 function mapZenkitError(status, payload, phase) {
     const message = readZenkitErrorMessage(payload) ?? `Zenkit request failed with status ${status}`;
     if (status === 429) {
-        return providerError("rate_limited", message, 429);
+        return new ProviderRequestError(429, message, undefined, "rate_limited");
     }
     if (phase === "validate" && status >= 400 && status < 500) {
-        return providerError("invalid_input", message, 400);
+        return new ProviderRequestError(400, message, undefined, "invalid_input");
     }
     if (status === 400 || status === 404 || status === 409 || status === 422) {
-        return providerError("invalid_input", message, status === 404 ? 404 : 400);
+        return new ProviderRequestError(status === 404 ? 404 : 400, message, undefined, "invalid_input");
     }
-    return providerError("provider_error", message, status || 502);
+    return new ProviderRequestError(status || 502, message, undefined, "provider_error");
 }
 function readZenkitErrorMessage(payload) {
     const body = optionalRecord(payload);
@@ -213,26 +213,20 @@ function requireAllId(value, fieldName) {
 }
 function requirePositiveInteger(value, fieldName) {
     if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        throw providerError("invalid_input", `${fieldName} must be a positive integer`, 400);
+        throw new ProviderRequestError(400, `${fieldName} must be a positive integer`, undefined, "invalid_input");
     }
     return value;
 }
 function requireInputObject(value, fieldName) {
     const object = optionalRecord(value);
     if (!object) {
-        throw providerError("invalid_input", `${fieldName} must be an object`, 400);
+        throw new ProviderRequestError(400, `${fieldName} must be an object`, undefined, "invalid_input");
     }
     return object;
 }
 function stringifyOptionalNumber(value) {
     return typeof value === "number" ? String(value) : undefined;
 }
-function stringifyOptionalBoolean(value) {
-    return typeof value === "boolean" ? String(value) : undefined;
-}
 function stringifyOptionalArray(value) {
     return Array.isArray(value) ? value.join(",") : undefined;
 }
-function providerError(code, message, status) {
-    return new ProviderRequestError(status, message, undefined, code);
-}

package/src/providers/zhiliaobiaoxun/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const zhiliaobiaoxunActions: ActionDefinition[];

package/src/providers/zhiliaobiaoxun/actions.js

@@ -0,0 +1,138 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const bidFields = {
+    bid_id: s.integer("The notice ID."),
+    title: s.string("The notice title."),
+    bid_type: s.string("The notice type returned by the provider, such as 招标 or 中标."),
+    bid_process: s.string("The procurement stage name."),
+    pub_time: s.string("The publication time as returned by the provider."),
+    money: s.nullable(s.number("The amount in CNY.")),
+    money_wan: s.nullable(s.number("The amount in ten thousand CNY.")),
+    province: s.string("The province name."),
+    city: s.string("The city name."),
+    county: s.string("The county or district name."),
+    caller_name: s.string("The purchaser name."),
+    winner_names: s.array("Winning suppliers.", s.string("A supplier name.")),
+    url: s.string("The notice URL on Zhiliao Biaoxun."),
+};
+const meta = s.looseObject("Request and billing metadata.", {
+    request_id: s.string("The upstream request ID."),
+    tool_name: s.string("The upstream tool name."),
+    cost_units: s.number("Credits charged for this request."),
+    execution_time_ms: s.number("Upstream execution time in milliseconds."),
+});
+function output(data) {
+    return s.looseRequiredObject("The successful upstream response, including billing metadata.", {
+        success: s.literal(true, { description: "Whether the request succeeded." }),
+        data,
+        error: s.nullable(s.looseObject("Upstream error information; null on success.", {})),
+        meta,
+    });
+}
+const bidList = s.looseObject("Matching procurement notices.", {
+    total: s.integer("The total number of matching notices."),
+    returned: s.integer("The number of notices returned on this page."),
+    items: s.array("Notices on this page.", s.looseObject("A procurement notice.", bidFields)),
+});
+const identity = {
+    bid_id: s.integer("The notice ID; pair it with bid_type."),
+    bid_type: s.integer("The notice type: 1 for tenders, 2 for awards.", { minimum: 1, maximum: 2 }),
+    bid_url: s.nonWhitespaceString("The notice URL; forwarded to the provider without downloading it."),
+};
+export const zhiliaobiaoxunActions = [
+    defineProviderAction("zhiliaobiaoxun", {
+        name: "search_bids",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search Chinese tender and award notices by keywords, region, publication date, or amount. Returns one page per call and charges provider credits. Increase page to continue.",
+        inputSchema: s.object("Notice search filters.", {
+            keywords: s.array("Search keywords.", s.nonWhitespaceString("A search keyword."), {
+                minItems: 1,
+            }),
+            match_modes: s.array("Fields in which to match keywords; omit for provider defaults.", s.stringEnum("A keyword matching mode.", [
+                "all",
+                "sm",
+                "title",
+                "brand",
+                "fulltext",
+                "caller",
+                "winner",
+                "winner_tender",
+                "tender",
+                "agency",
+            ])),
+            bid_type: s.stringEnum("Notice category: 招标 for tenders, 中标 for awards, 全部 for both.", [
+                "招标",
+                "中标",
+                "全部",
+            ]),
+            bid_process: s.array("Procurement stages: 1 intent, 2 pre-tender, 4 tender, 5 amendment, 6 award candidates, 7 award, 8 contract, 9 acceptance, 10 cancellation. Default: [1,2,4,7,8].", s.integer("A procurement stage ID.")),
+            begin_date: s.string("Inclusive publication start date, YYYY-MM-DD.", { format: "date" }),
+            end_date: s.string("Inclusive publication end date, YYYY-MM-DD.", { format: "date" }),
+            provinces: s.array("Province names, such as 北京 or 内蒙古.", s.nonWhitespaceString("A province name.")),
+            cities: s.array("City names, such as 石家庄 or 合肥.", s.nonWhitespaceString("A city name.")),
+            counties: s.array("County or district names, such as 长安区.", s.nonWhitespaceString("A county or district name.")),
+            min_amount: s.number("Minimum amount in ten thousand CNY."),
+            max_amount: s.number("Maximum amount in ten thousand CNY."),
+            page: s.integer("Page number, starting at 1; defaults to 1.", { minimum: 1, default: 1 }),
+            page_size: s.integer("Notices per page; defaults to 20.", { minimum: 1, default: 20 }),
+        }, { required: ["keywords"] }),
+        outputSchema: output(bidList),
+    }),
+    defineProviderAction("zhiliaobiaoxun", {
+        name: "get_bid_detail",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a procurement notice with its full text and attachment links. Supply a notice URL, unique key, or notice ID. Charges provider credits; attachments are returned as URLs.",
+        inputSchema: {
+            ...s.object("Notice identifiers; supply at least one locator.", {
+                ...identity,
+                uniq_key: s.nonWhitespaceString("The provider's unique notice key."),
+            }, { required: [] }),
+            anyOf: [{ required: ["bid_id"] }, { required: ["bid_url"] }, { required: ["uniq_key"] }],
+        },
+        outputSchema: output(s.looseObject("Notice details, preserving additional provider fields.", {
+            ...bidFields,
+            uniq_key: s.string("The provider's unique notice key."),
+            source: s.string("The notice body."),
+            source_ext: s.string("Extracted attachment content."),
+            source_url: s.string("The original publication URL."),
+            attachment_urls: s.array("Attachment URLs; no files are downloaded by this action.", s.string("An attachment URL.")),
+            contact_privacy: s.string("Provider contact visibility: full or masked, depending on the account."),
+        })),
+    }),
+    defineProviderAction("zhiliaobiaoxun", {
+        name: "get_bid_timeline",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Retrieve notices for every stage of the same procurement project, ordered by publication time ascending. Supply a notice URL or a notice ID with its type. Charges provider credits.",
+        inputSchema: {
+            ...s.object("A notice identifying the procurement project.", {
+                ...identity,
+                bid_type: {
+                    type: ["integer", "string"],
+                    enum: [1, 2, "1", "2"],
+                    description: "The notice type: 1 for tenders, 2 for awards; numeric strings are accepted.",
+                },
+            }, { required: [] }),
+            anyOf: [{ required: ["bid_url"] }, { required: ["bid_id", "bid_type"] }],
+        },
+        outputSchema: output(s.looseObject("The project timeline.", {
+            total: s.integer("The number of notices across project stages."),
+            items: s.array("Project notices ordered by publication time ascending.", s.looseObject("A procurement notice.", bidFields)),
+        })),
+    }),
+    defineProviderAction("zhiliaobiaoxun", {
+        name: "get_account_balance",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read available credits and cumulative charged and consumed credits for the connected account. This endpoint does not consume credits.",
+        inputSchema: s.requiredObject("No input parameters are required.", {}),
+        outputSchema: output(s.looseObject("Account credit balance.", {
+            user_id: s.integer("The account ID associated with the API key."),
+            balance: s.number("Available credits."),
+            total_charged: s.number("Cumulative credits added to the account."),
+            total_consumed: s.number("Cumulative credits consumed."),
+        })),
+    }),
+];

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

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

package/src/providers/zhiliaobiaoxun/executors.js

@@ -0,0 +1,78 @@
+import { optionalRecord, optionalRawString, optionalNumber } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { zhiliaobiaoxunActions } from "./actions.js";
+const baseUrl = "https://mcp-server.zhiliaobiaoxun.com/api_v2";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+async function request({ actionName, body, apiKey, fetcher, parentSignal }) {
+    return runProviderRequest({ signal: parentSignal, label: "Zhiliao Biaoxun" }, async (signal) => {
+        const isBalance = actionName === "get_account_balance";
+        const response = await fetcher(`${baseUrl}/${isBalance ? "account/balance" : actionName}`, {
+            method: isBalance ? "GET" : "POST",
+            headers: { ...defaultHeaders, "X-API-Key": apiKey },
+            signal,
+            body: isBalance ? undefined : JSON.stringify(body),
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const envelope = optionalRecord(payload);
+        if (!response.ok || envelope?.success !== true) {
+            const error = optionalRecord(envelope?.error);
+            const code = optionalRawString(error?.code);
+            const message = optionalRawString(error?.message) || `HTTP ${response.status}; invalid or unsuccessful response`;
+            const detail = [code, message].filter(Boolean).join(": ").split(apiKey).join("[REDACTED]");
+            const limited = response.status === 429 || code === "RATE_LIMITED";
+            throw new ProviderRequestError(response.ok ? (limited ? 429 : 502) : response.status, `Zhiliao Biaoxun request failed: ${detail}`, undefined, limited ? "rate_limited" : "provider_error");
+        }
+        return envelope;
+    });
+}
+const handlers = mapProviderActionHandlers("zhiliaobiaoxun", zhiliaobiaoxunActions, (action) => async (dataInput, context) => {
+    return request({
+        actionName: action.name,
+        body: dataInput,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("zhiliaobiaoxun", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const response = await request({
+            actionName: "get_account_balance",
+            body: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        const data = requiredResponseRecord(response.data, "Zhiliao Biaoxun account data");
+        const userId = optionalNumber(data.user_id);
+        return {
+            profile: { displayName: userId == null ? "Zhiliao Biaoxun API Key" : `Zhiliao Biaoxun ${userId}` },
+            grantedScopes: [],
+            metadata: {},
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "zhiliaobiaoxun",
+    baseUrl,
+    auth: { type: "api_key_header", name: "X-API-Key" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "content-type": "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});

package/src/server/api/auth.d.ts

@@ -7,6 +7,8 @@ import type { Context, MiddlewareHandler } from "hono";
 export interface LocalAuthOptions {
     adminToken?: string;
     runtimeToken?: string;
+    /** Keep runtime endpoints protected even when the last stored token is revoked. */
+    requireRuntimeAuth?: boolean;
     hasRuntimeTokens?(): Promise<boolean>;
     resolveRuntimeToken?(token: string): Promise<RuntimeGrant | undefined>;
     verifyRuntimeJwt?: RuntimeJwtVerifier;

package/src/server/api/auth.js

@@ -20,6 +20,7 @@ export function createLocalAuthMiddleware(options) {
     const runtimeToken = normalizeToken(options.runtimeToken);
     if (!adminToken &&
         !runtimeToken &&
+        !options.requireRuntimeAuth &&
         !options.hasRuntimeTokens &&
         !options.resolveRuntimeToken &&
         !options.verifyRuntimeJwt) {
@@ -140,7 +141,7 @@ async function hasValidToken(context, options, scope) {
         const hasRuntimeTokens = options.hasRuntimeTokens
             ? await options.hasRuntimeTokens()
             : options.resolveRuntimeToken !== undefined;
-        if (!hasRuntimeTokens && !options.verifyRuntimeJwt) {
+        if (!options.requireRuntimeAuth && !hasRuntimeTokens && !options.verifyRuntimeJwt) {
             return true;
         }
         return hasValidRuntimeToken(context, options);

package/src/server/api/console-catalog-routes.d.ts

@@ -0,0 +1,17 @@
+import type { CatalogStore } from "../../catalog-store.ts";
+import type { ConnectionService } from "../../connection-service.ts";
+import type { ActionPolicySnapshot } from "../../core/action-policy.ts";
+import type { ActionSearchDocument, ActionSearchIndexProvider } from "../../core/action-search.ts";
+import type { Context } from "hono";
+import { Hono } from "hono";
+export interface ConsoleCatalogRoutesOptions {
+    catalog: CatalogStore;
+    connections: ConnectionService;
+    actionSearch: ActionSearchIndexProvider;
+    publicOrigin: string;
+    getPolicySnapshot: (context: Context) => Promise<ActionPolicySnapshot>;
+    readConnectionName?: (context: Context, body?: Record<string, unknown>) => string | undefined;
+    serializeSearchResults?: (results: ActionSearchDocument[]) => Promise<unknown[]>;
+}
+/** Console catalog, providers, actions and documentation routes. */
+export declare function createConsoleCatalogRoutes({ catalog, connections, actionSearch, publicOrigin, getPolicySnapshot, readConnectionName, serializeSearchResults: injectedSerializeSearchResults, }: ConsoleCatalogRoutesOptions): Hono;

package/src/server/api/console-catalog-routes.js

@@ -0,0 +1,88 @@
+import { Hono } from "hono";
+import { ConnectionError } from "../../connection-service.js";
+import { searchActions } from "../../core/action-search.js";
+import { renderActionMarkdown } from "./action-markdown.js";
+import { jsonError, notFound, readConnectionName as defaultReadConnectionName } from "./http-utils.js";
+import { mapConnectionErrorStatus } from "./runtime-api.js";
+import { readSearchQuery, serializeActionSearchResult } from "./runtime-catalog-routes.js";
+function stripWeakPrefix(etag) {
+    return etag.startsWith("W/") ? etag.slice(2) : etag;
+}
+function requestMatchesEtag(ifNoneMatch, etag) {
+    if (!ifNoneMatch)
+        return false;
+    if (ifNoneMatch.trim() === "*")
+        return true;
+    const target = stripWeakPrefix(etag);
+    return ifNoneMatch.split(",").some((candidate) => stripWeakPrefix(candidate.trim()) === target);
+}
+/** Console catalog, providers, actions and documentation routes. */
+export function createConsoleCatalogRoutes({ catalog, connections, actionSearch, publicOrigin, getPolicySnapshot, readConnectionName = defaultReadConnectionName, serializeSearchResults: injectedSerializeSearchResults, }) {
+    const app = new Hono();
+    const serializeSearchResults = injectedSerializeSearchResults ??
+        (async (results) => {
+            const authenticated = new Set(await connections.listAuthenticatedServices([...new Set(results.map((result) => result.service))]));
+            return results.flatMap((result) => {
+                const action = catalog.actionsById.get(result.id);
+                if (!action)
+                    return [];
+                return [serializeActionSearchResult(result, action, authenticated.has(action.service))];
+            });
+        });
+    app.get("/providers", (context) => {
+        const { providerSummariesJson, providerSummariesEtag } = catalog;
+        context.header("ETag", providerSummariesEtag);
+        if (requestMatchesEtag(context.req.header("If-None-Match"), providerSummariesEtag)) {
+            return context.body(null, 304);
+        }
+        return context.body(providerSummariesJson, 200, { "Content-Type": "application/json" });
+    });
+    app.get("/providers/:service", (context) => {
+        const provider = catalog.providers.find((p) => p.service === context.req.param("service"));
+        if (!provider)
+            return notFound(context);
+        return context.json(provider);
+    });
+    app.get("/actions", (context) => context.json(catalog.actions));
+    app.get("/actions/search", async (context) => {
+        const query = readSearchQuery(context);
+        if (!query.ok) {
+            return jsonError(context, 400, "invalid_input", query.message);
+        }
+        const index = await actionSearch.get();
+        return context.json(await serializeSearchResults(searchActions(index, query.q, {
+            service: query.service,
+            limit: query.limit,
+        })));
+    });
+    app.get("/actions/:actionId/agent.md", async (context) => {
+        const actionId = context.req.param("actionId");
+        const action = catalog.actionsById.get(actionId);
+        if (!action)
+            return notFound(context);
+        try {
+            const policy = (await getPolicySnapshot(context)).evaluate(action);
+            return context.text(renderActionMarkdown(action, {
+                transport: { kind: "http", origin: publicOrigin },
+                connection: await connections.getConnectionSummary(action.service, readConnectionName(context)),
+                policy,
+            }), 200, {
+                "content-type": "text/markdown; charset=utf-8",
+            });
+        }
+        catch (error) {
+            if (error instanceof ConnectionError) {
+                const status = mapConnectionErrorStatus(error);
+                return jsonError(context, status, error.code, error.message);
+            }
+            throw error;
+        }
+    });
+    app.get("/actions/:actionId", (context) => {
+        const action = catalog.actionsById.get(context.req.param("actionId"));
+        if (!action)
+            return notFound(context);
+        return context.json(action);
+    });
+    return app;
+}

package/src/server/api/console-oauth-routes.d.ts

@@ -0,0 +1,18 @@
+import type { ConnectionService } from "../../connection-service.ts";
+import type { RuntimeLogger } from "../../core/types.ts";
+import type { OAuthClientConfigService } from "../../oauth/oauth-client-config-service.ts";
+import type { OAuthFlowService } from "../../oauth/oauth-flow-service.ts";
+import type { SaasProjectService } from "../../saas/saas-project-service.ts";
+import type { Context } from "hono";
+import { Hono } from "hono";
+export interface ConsoleOAuthRoutesOptions {
+    connections: ConnectionService;
+    oauthFlow: OAuthFlowService;
+    oauthClientConfigs: OAuthClientConfigService;
+    saasProject?: SaasProjectService;
+    logger?: RuntimeLogger;
+    oauthCloseDelaySeconds?: number;
+    readConnectionName?: (context: Context, body?: Record<string, unknown>) => string | undefined;
+}
+/** Console connection management and OAuth client configuration / authorization routes. */
+export declare function createConsoleOAuthRoutes({ connections, oauthFlow, oauthClientConfigs, saasProject, logger, oauthCloseDelaySeconds, readConnectionName, }: ConsoleOAuthRoutesOptions): Hono;