@oomol-lab/open-connector 1.6.5 → 1.7.0

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

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

package/src/providers/wisburg/executors.js

@@ -0,0 +1,13 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { validateWisburgCredential, wisburgActionHandlers, wisburgApiBaseUrl } from "./runtime.js";
+const service = "wisburg";
+export const executors = defineApiKeyProviderExecutors(service, wisburgActionHandlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: wisburgApiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+});
+export const credentialValidators = { apiKey: validateWisburgCredential };

package/src/providers/wisburg/runtime.d.ts

@@ -0,0 +1,12 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderRuntimeHandler } from "../provider-runtime.ts";
+/** Output key a detail action nests its resource under. */
+export type WisburgDetailKey = "report" | "article" | "log";
+export declare const wisburgApiBaseUrl = "https://api-omen.wisburg.com";
+export declare const wisburgActionHandlers: ProviderActionHandlers<"wisburg", ProviderRuntimeHandler<ApiKeyProviderContext>>;
+export declare function validateWisburgCredential(input: {
+    apiKey: string;
+}, { fetcher, signal }: {
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<CredentialValidationResult>;

package/src/providers/wisburg/runtime.js

@@ -0,0 +1,133 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { objectArray, optionalInteger, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
+import { ProviderRequestError, parseProviderJsonBodyText, providerResponseError, providerUserAgent, readProviderErrorTextBody, readProviderJsonBody, requiredInputNumber, requiredResponseRecord, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
+export const wisburgApiBaseUrl = "https://api-omen.wisburg.com";
+export const wisburgActionHandlers = {
+    list_reports: (input, context) => listWisburgResource(input, context, "api/reports"),
+    get_report: (input, context) => getWisburgResource(input, context, "api/reports", "report"),
+    list_archives: (input, context) => listWisburgResource(input, context, "api/archives"),
+    get_archive: (input, context) => getWisburgResource(input, context, "api/archives", "report"),
+    list_company_reports: (input, context) => listWisburgResource(input, context, "api/company-reports"),
+    get_company_report: (input, context) => getWisburgResource(input, context, "api/company-reports", "report"),
+    list_earnings_calls: (input, context) => listWisburgResource(input, context, "api/earningscalls"),
+    get_earnings_call: (input, context) => getWisburgResource(input, context, "api/earningscalls", "report"),
+    list_articles: (input, context) => listWisburgResource(input, context, "api/articles"),
+    get_article: (input, context) => getWisburgResource(input, context, "api/articles", "article"),
+    list_market_daily: (input, context) => listWisburgResource(input, context, "api/market-daily"),
+    list_feed: (input, context) => listWisburgResource(input, context, "api/feed"),
+    list_images: (input, context) => listWisburgResource(input, context, "api/images"),
+    list_am_reports: (input, context) => listWisburgResource(input, context, "api/am-reports"),
+    get_am_report: (input, context) => getWisburgResource(input, context, "api/am-reports", "report"),
+    list_mikko_logs: (input, context) => listWisburgResource(input, context, "api/mikko-logs"),
+    get_mikko_log: (input, context) => getWisburgResource(input, context, "api/mikko-logs", "log"),
+};
+export async function validateWisburgCredential(input, { fetcher, signal }) {
+    try {
+        await wisburgRequest({ apiKey: input.apiKey, fetcher, signal }, { path: "api/feed", query: { first: "1" } });
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError && error.status === 401) {
+            throw new ProviderRequestError(400, error.message, error.details);
+        }
+        // A 403 proves the key was accepted; the feed is simply outside this key's subscription.
+        if (!(error instanceof ProviderRequestError) || error.status !== 403)
+            throw error;
+    }
+    return {
+        profile: {
+            accountId: `wisburg:${sha256Hex(input.apiKey).slice(0, 32)}`,
+            displayName: "Wisburg API Key",
+        },
+        grantedScopes: [],
+        metadata: {
+            apiBaseUrl: wisburgApiBaseUrl,
+            validationEndpoint: "/api/feed",
+            credentialHelpUrl: "https://open-docs.wisburg.com/docs/getting-started/first-call",
+        },
+    };
+}
+async function listWisburgResource(input, context, path) {
+    const envelope = await wisburgRequest(context, {
+        path,
+        query: {
+            first: optionalInteger(input.first)?.toString(),
+            after: optionalString(input.after),
+            query: optionalString(input.query),
+            startTime: optionalString(input.startTime),
+            endTime: optionalString(input.endTime),
+        },
+    });
+    const data = requiredResponseRecord(envelope.data, "Wisburg list data");
+    const pageInfo = requiredResponseRecord(data.page_info, "Wisburg list page_info");
+    const endCursor = pageInfo.end_cursor;
+    if (endCursor != null && typeof endCursor !== "string") {
+        throw providerResponseError("Wisburg list page_info.end_cursor must be a string");
+    }
+    return {
+        requestId: optionalString(envelope.request_id) ?? "",
+        items: objectArray(data.items, "Wisburg list data.items", providerResponseError),
+        pageInfo: { endCursor: optionalString(endCursor) },
+    };
+}
+async function getWisburgResource(input, context, path, key) {
+    const id = requiredInputNumber(input.id, "id");
+    const envelope = await wisburgRequest(context, { path: `${path}/${id}` });
+    return {
+        requestId: optionalString(envelope.request_id) ?? "",
+        [key]: requiredResponseRecord(envelope.data, "Wisburg detail data"),
+    };
+}
+async function wisburgRequest(context, input) {
+    return runProviderRequest({ signal: context.signal, label: "Wisburg" }, async (signal) => {
+        const url = new URL(input.path, `${wisburgApiBaseUrl}/`);
+        setSearchParams(url, input.query ?? {});
+        const response = await context.fetcher(url, {
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${context.apiKey}`,
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        if (!response.ok) {
+            throw await readWisburgHttpError(response);
+        }
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "Wisburg returned invalid JSON",
+        });
+        const envelope = requiredResponseRecord(payload, "Wisburg response");
+        const code = optionalNumber(envelope.code);
+        if (code !== undefined && code !== 200) {
+            throw mapWisburgError(code, envelope);
+        }
+        // The envelope marks failure as status 1 even when the code field disagrees; fall back to the 1002 internal-error code when none is present.
+        if (optionalNumber(envelope.status) === 1) {
+            throw mapWisburgError(code ?? 1002, envelope);
+        }
+        return envelope;
+    });
+}
+// Keep the HTTP status for non-JSON gateway error pages; the JSON envelope, when present, only supplies the code and message.
+async function readWisburgHttpError(response) {
+    const text = await readProviderErrorTextBody(response, "Wisburg error response");
+    const parsed = parseProviderJsonBodyText(text, {
+        emptyBody: {},
+        invalidJsonMessage: "Wisburg returned invalid JSON",
+        invalidJsonFallback: () => ({}),
+    });
+    const envelope = optionalRecord(parsed) ?? {};
+    return mapWisburgError(optionalNumber(envelope.code) ?? response.status, envelope);
+}
+function mapWisburgError(code, envelope) {
+    const message = optionalString(envelope.message) ?? `Wisburg request failed (${code})`;
+    // Besides the documented 401/403/404/429 codes, a bare gateway 4xx such as 414 stays a client error.
+    if (code >= 400 && code < 500) {
+        return new ProviderRequestError(code, message, envelope);
+    }
+    // 1001 marks invalid parameters and 1004 an out-of-range pagination cursor.
+    if (code === 1001 || code === 1004) {
+        return new ProviderRequestError(400, message, envelope);
+    }
+    return new ProviderRequestError(502, message, envelope);
+}

package/src/providers/xydc_mcp/executors.js

@@ -38,7 +38,7 @@ export const proxy = defineProviderProxy({
     },
     timeoutMs: generationTimeoutMs,
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     customizeRequest({ headers }) {
         headers.set("accept", "application/json, text/event-stream");
         headers.set("content-type", "application/json");
@@ -61,7 +61,7 @@ async function withClient(context, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers: { authorization: `Bearer ${context.apiKey}`, "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError,
     }, run);

package/src/providers/youtube/executors.js

@@ -1,4 +1,4 @@
-import { googleJsonRequest } from "../google-runtime.js";
+import { googleJsonRequest } from "../googledrive/runtime-request.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, providerProxyEndpointPrefixes, } from "../provider-runtime.js";
 import { youtubeActionHandlers } from "./runtime.js";
 const service = "youtube";

package/src/providers/youtube/runtime.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { compactObject, optionalBoolean, optionalInteger, optionalString, rawStringOrNull } from "../../core/cast.js";
 import { assertPublicHttpUrl, readBoundedResponseBytes } from "../../core/request.js";
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
+import { googleJsonRequest, googleRequest } from "../googledrive/runtime-request.js";
 import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
 const youtubeApiBaseUrl = "https://www.googleapis.com/youtube/v3";
 const youtubeUploadApiBaseUrl = "https://www.googleapis.com/upload/youtube/v3";

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

@@ -0,0 +1,9 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { ProviderActionHandlers, ProviderRuntimeHandler } from "../provider-runtime.ts";
+import type { ZerotierActionContext } from "./runtime.ts";
+type ZerotierHandler = ProviderRuntimeHandler<ZerotierActionContext>;
+export declare const zerotierActionHandlers: ProviderActionHandlers<"zerotier", ZerotierHandler>;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;
+export declare const credentialValidators: CredentialValidators;
+export {};