nexus-ai-pro 2.20.2 → 2.22.0

package/dist/adapter-kit/record.js

@@ -161,7 +161,7 @@ export function compatibilityPage(records, options = {}) {
             record,
             status,
             cells: [
-                record.adapter.repository
+                record.adapter.repository && /^https?:\/\//i.test(record.adapter.repository)
                     ? { text: record.adapter.name, href: record.adapter.repository }
                     : { text: record.adapter.name },
                 { text: record.adapter.kind },
@@ -187,7 +187,8 @@ export function compatibilityPage(records, options = {}) {
         const cell = (item) => item.href ? `<a href="${escapeHtml(item.href)}">${escapeHtml(item.text)}</a>` : escapeHtml(item.text);
         return [
             '<!doctype html>',
-            `<html lang="en"><head><meta charset="utf-8"><title>${escapeHtml(title)}</title></head><body>`,
+            `<html lang="en"><head><meta charset="utf-8"><title>${escapeHtml(title)}</title>`,
+            `<style>${STATE_STYLE}</style></head><body>`,
             `<h1>${escapeHtml(title)}</h1>`,
             ...(options.intro ? [`<p>${escapeHtml(options.intro)}</p>`] : []),
             `<p>States are judged against nexus-ai-pro ${escapeHtml(nexusVersion)}.</p>`,
@@ -207,9 +208,11 @@ export function compatibilityPage(records, options = {}) {
             '',
         ].join('\n');
     }
+    const literal = (text) => oneLine(text).replace(/[|[\]*_`\\]/g, (char) => `\\${char}`);
     const cell = (item) => {
-        const text = item.text.replace(/\|/g, '\\|');
-        return item.href ? `[${text}](${item.href.replace(/\|/g, '%7C')})` : text;
+        const text = literal(item.text);
+        const href = item.href?.replace(/[|\s()]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`);
+        return href ? `[${text}](${href})` : text;
     };
     return [
         `# ${title}`,
@@ -221,7 +224,10 @@ export function compatibilityPage(records, options = {}) {
         `| ${headers.map(() => '---').join(' | ')} |`,
         ...rows.map((row) => `| ${row.cells.map(cell).join(' | ')} |`),
         ...(notes.length > 0
-            ? ['', ...notes.map((row) => `- **${row.record.adapter.name}**: ${row.status.reasons.join('; ')}`)]
+            ? [
+                '',
+                ...notes.map((row) => `- **${literal(row.record.adapter.name)}**: ${row.status.reasons.map(literal).join('; ')}`),
+            ]
             : []),
         '',
     ].join('\n');
@@ -240,6 +246,15 @@ function runtimeName() {
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+const STATE_STYLE = [
+    'tr[data-state="passing"] td{color:#1a7f37}',
+    'tr[data-state="failing"] td{color:#cf222e;font-weight:600}',
+    'tr[data-state="incompatible"] td{color:#9a6700}',
+    'tr[data-state="stale"] td{color:#57606a}',
+].join('');
+function oneLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
 function escapeHtml(text) {
     return text.replace(/[&<>"']/g, (char) => `&#${char.charCodeAt(0)};`);
 }

package/dist/agent/openapi.d.ts

@@ -44,6 +44,38 @@ export interface OpenApiOperation {
     tags: string[];
     /** What it does to the service, read from its method: `read` for GET, HEAD, OPTIONS, and TRACE, `destructive` for DELETE, and `write` for the rest. */
     access: 'read' | 'write' | 'destructive';
+    /**
+     * The security it asks for, as the document writes it: alternatives, any one of which will do, each
+     * the schemes it needs at once with their scopes. Empty when it asks for none.
+     */
+    security: Array<Record<string, string[]>>;
+}
+/**
+ * A credential for one of the API's security schemes: the API key, bearer token, or access token as
+ * text or `{ token }`; `{ username, password }` for HTTP basic; or `{ clientId, clientSecret }` for an
+ * OAuth 2.0 client-credentials flow, whose token is fetched and kept until it expires.
+ */
+export type OpenApiCredential = string | {
+    token: string;
+} | {
+    username: string;
+    password: string;
+} | {
+    clientId: string;
+    clientSecret: string;
+};
+/** A request or callback the API sends to the application, which no tool calls: its name and the body it carries. */
+export interface OpenApiWebhook {
+    /** The webhook's name, or the operation and callback it belongs to. */
+    name: string;
+    /** `webhook` for one of the document's webhooks, `callback` for an operation's callback. */
+    source: 'webhook' | 'callback';
+    /** The HTTP method it arrives with, in capitals. */
+    method: string;
+    /** For a callback, the expression that names where it is sent, such as `{$request.body#/callbackUrl}`. */
+    expression?: string;
+    /** The JSON Schema of the body it carries, when it carries JSON. */
+    body?: Record<string, unknown>;
 }
 /** What a tool's headers are chosen from: the operation, and the call's context. */
 export interface OpenApiHeadersRequest {
@@ -79,6 +111,15 @@ export interface OpenApiToolsOptions {
     maxResponseBytes?: number;
     /** Replaces the global `fetch`. */
     fetch?: typeof globalThis.fetch;
+    /**
+     * Credentials for the API's own security schemes, by the name the document gives each, or a
+     * function choosing one per call, such as by its tenant. Each call sends those its operation asks
+     * for: the first of its alternatives every scheme of which has a credential, as an API key in its
+     * header, query, or cookie, HTTP basic or bearer, or an OAuth 2.0 or OpenID Connect token. With
+     * credentials given, a call whose operation asks for schemes none of which has one fails before it
+     * is sent. They win over `headers`.
+     */
+    credentials?: Readonly<Record<string, OpenApiCredential | ((request: OpenApiHeadersRequest) => OpenApiCredential | Promise<OpenApiCredential>)>>;
 }
 /** An API's operations as tools, with what each returns. */
 export interface OpenApiTools {
@@ -92,19 +133,26 @@ export interface OpenApiTools {
     operations: OpenApiOperation[];
     /** The JSON Schema of what each tool returns, by name: its first success response's. Pass it to `emulatedTools()` as `results`. */
     results: Record<string, Record<string, unknown>>;
-    /** Operations that could not become tools, and why: a request body of a type the tools do not send. */
+    /**
+     * Operations that could not become tools, and why.
+     *
+     * @deprecated Every operation becomes a tool since 2.22, its body sent whatever its type, so this is
+     * always empty. It is removed in 3.0.
+     */
     skipped: Array<{
         method: string;
         path: string;
         reason: string;
     }>;
+    /** What the API sends the application, which no tool calls: its webhooks and its operations' callbacks. */
+    webhooks: OpenApiWebhook[];
 }
 /** Why an API could not be read into tools, or a call to it failed. */
 export declare class OpenApiError extends Error {
     /**
      * `OPENAPI_INVALID` for a malformed document or call, `OPENAPI_UNSUPPORTED` for one these tools
-     * cannot read, such as Swagger 2.0 or a reference outside the document, and `OPENAPI_REQUEST`
-     * for a call the API refused or did not answer.
+     * cannot read, such as Swagger 1.2 or a reference outside the document not bundled first, and
+     * `OPENAPI_REQUEST` for a call the API refused or did not answer.
      */
     readonly code: 'OPENAPI_INVALID' | 'OPENAPI_UNSUPPORTED' | 'OPENAPI_REQUEST';
     /** The HTTP status the API answered with, when it did. */
@@ -112,8 +160,8 @@ export declare class OpenApiError extends Error {
     constructor(message: string, 
     /**
      * `OPENAPI_INVALID` for a malformed document or call, `OPENAPI_UNSUPPORTED` for one these tools
-     * cannot read, such as Swagger 2.0 or a reference outside the document, and `OPENAPI_REQUEST`
-     * for a call the API refused or did not answer.
+     * cannot read, such as Swagger 1.2 or a reference outside the document not bundled first, and
+     * `OPENAPI_REQUEST` for a call the API refused or did not answer.
      */
     code: 'OPENAPI_INVALID' | 'OPENAPI_UNSUPPORTED' | 'OPENAPI_REQUEST', 
     /** The HTTP status the API answered with, when it did. */
@@ -124,7 +172,10 @@ export declare class OpenApiError extends Error {
  * method and path; described by its summary; its path, query, and header parameters, and the fields
  * of a JSON body, as the tool's parameters. Each declares `api.read`, `api.write`, or
  * `api.destructive` with the API's name and its own, as its method says, and `network` for the
- * API's host when it runs. References within the document are followed; one outside it is refused.
+ * API's host when it runs. References within the document are followed; one outside it is refused
+ * here, and followed by `loadOpenApiTools()` or `bundleOpenApiDocument()`. A Swagger 2.0 document is
+ * read as the OpenAPI 3 document it describes. Each call sends the credentials its operation's
+ * security asks for, from `credentials`.
  *
  * ```ts
  * const shop = openApiTools(JSON.parse(await readFile('shop.openapi.json', 'utf8')), {
@@ -135,5 +186,40 @@ export declare class OpenApiError extends Error {
  * ```
  */
 export declare function openApiTools(document: OpenApiDocument | string, options?: OpenApiToolsOptions): OpenApiTools;
-/** Fetches an OpenAPI document, as JSON, and reads it into tools, resolving its servers against where it came from. */
-export declare function loadOpenApiTools(url: string, options?: OpenApiToolsOptions): Promise<OpenApiTools>;
+/**
+ * Fetches an OpenAPI document, as JSON, and reads it into tools, resolving its servers against where
+ * it came from, and following its references to other documents on the same origin, or as
+ * `references` allows.
+ */
+export declare function loadOpenApiTools(url: string, options?: OpenApiToolsOptions & Pick<OpenApiBundleOptions, 'references' | 'maxDocuments' | 'maxBytes'>): Promise<OpenApiTools>;
+/**
+ * A Swagger 2.0 document as the OpenAPI 3.0 document it describes: its host, base path, and schemes
+ * as a server; its definitions, parameters, responses, and security definitions as components; a
+ * body parameter, and form data, as a request body of what it consumes; and each response's schema as
+ * content of what it produces. Every reference is moved with what it names.
+ */
+export declare function swaggerToOpenApi(swagger: Record<string, unknown>): OpenApiDocument;
+/** Options for `bundleOpenApiDocument()`. */
+export interface OpenApiBundleOptions {
+    /** Where the document came from: references outside it are read relative to it. */
+    documentUrl: string;
+    /**
+     * Which documents a reference may name: `same-origin`, the default, only those on the document's
+     * own origin; `any`, any HTTP or HTTPS URL; or a function deciding each. A document never makes the
+     * tools fetch where it was not allowed to.
+     */
+    references?: 'same-origin' | 'any' | ((url: string) => boolean);
+    /** The most documents read, the first included. Defaults to 50. */
+    maxDocuments?: number;
+    /** The largest document read, the first included, in bytes. Defaults to 5 MB. */
+    maxBytes?: number;
+    /** Replaces the global `fetch`. */
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * The document with every reference outside it read in its place: each other document fetched, as
+ * JSON, relative to the one that names it, its own references followed the same way, and a reference
+ * back to one still being read left as a description. `loadOpenApiTools()` does this before reading the
+ * document into tools.
+ */
+export declare function bundleOpenApiDocument(document: OpenApiDocument, options: OpenApiBundleOptions): Promise<OpenApiDocument>;