@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/fireflies/trigger-on-meeting-ready.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const firefliesMeetingReady: IntegrationDefinition;

package/src/providers/fireflies/trigger-on-meeting-ready.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "integration";
+};

package/src/providers/fireflies/trigger-on-meeting-ready.definition.js

@@ -0,0 +1,44 @@
+export const snapshot = {
+    key: "fireflies.on_meeting_ready",
+    provider: "fireflies",
+    name: "on_meeting_ready",
+    displayName: "Meeting Transcript or Summary Ready",
+    description: "Receives separate transcript and summary readiness events through Fireflies Webhooks V2 after checking meeting access.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "sourceId",
+            jsonSchema: { type: "string", pattern: "^source_[0-9a-f]{32}$", title: "Event source" },
+            nullable: false,
+        },
+        {
+            handle: "eventTypes",
+            jsonSchema: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: ["meeting.transcribed", "meeting.summarized"],
+                },
+                minItems: 1,
+                maxItems: 2,
+                uniqueItems: true,
+                title: "Events",
+            },
+            nullable: false,
+            value: ["meeting.transcribed", "meeting.summarized"],
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "deliveryId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "accountId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "meetingId", jsonSchema: { type: "string" }, nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};

package/src/providers/fireflies/trigger-on-meeting-ready.js

@@ -0,0 +1,60 @@
+import { TransientIntegrationError } from "../../triggers/common/integration.js";
+import { PermanentIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { webhookRequest } from "../../triggers/managed-webhook.js";
+import { firefliesAccount } from "../../triggers/sources/fireflies.js";
+import { snapshot } from "./trigger-on-meeting-ready.definition.js";
+export const firefliesMeetingReady = {
+    snapshot,
+    eventSource: "fireflies",
+    source: firefliesAccount,
+    async sourceIdentity(context) {
+        const accountId = context.connector.providerAccountId;
+        if (!accountId)
+            throw new PermanentIntegrationError("Fireflies requires a verified connection identity.");
+        const meetingId = context.config.meetingId;
+        if (meetingId == null)
+            return { accountId };
+        if (typeof meetingId !== "string" || !meetingId || meetingId.length > 256)
+            throw new PermanentIntegrationError("Invalid Fireflies meeting ID.");
+        const result = await webhookRequest(context, {
+            method: "POST",
+            endpoint: "/graphql",
+            body: {
+                query: "query TriggerMeeting($id: String!) { transcript(id: $id) { id } }",
+                variables: { id: meetingId },
+            },
+        });
+        if (!isJsonObject(result.data))
+            throw new TransientIntegrationError("Invalid Fireflies access response.");
+        if (Array.isArray(result.data.errors) && result.data.errors.length) {
+            const denied = result.data.errors.every((error) => isJsonObject(error) &&
+                ["object_not_found", "forbidden", "not_in_team"].includes(String(isJsonObject(error.extensions) ? error.extensions.code : error.code)));
+            if (denied)
+                return { accountId, meetingId, accessible: false };
+            throw new TransientIntegrationError("Fireflies could not verify meeting access. Check API permissions, plan and availability.");
+        }
+        if (!isJsonObject(result.data.data))
+            throw new TransientIntegrationError("Invalid Fireflies access response.");
+        const transcript = result.data.data.transcript;
+        if (transcript == null)
+            return { accountId, meetingId, accessible: false };
+        if (!isJsonObject(transcript) || transcript.id !== meetingId)
+            throw new TransientIntegrationError("Fireflies returned a different meeting.");
+        return { accountId, meetingId, accessible: true };
+    },
+    receive(context) {
+        if (context.eventSourceId !== context.config.sourceId)
+            return { outcome: "respond", status: 404, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) ||
+            typeof payload.deliveryId !== "string" ||
+            !payload.deliveryId ||
+            !isJsonObject(payload.body))
+            throw new PermanentIntegrationError("Invalid shared Fireflies event.");
+        return { outcome: "event", dedupeKey: payload.deliveryId, outputs: payload };
+    },
+    async reconcile() {
+        throw new PermanentIntegrationError("This deployment does not support shared Fireflies event sources.");
+    },
+};

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

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

package/src/providers/ftshare/actions.js

@@ -0,0 +1,124 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const stockFields = {
+    stock_code: s.string("Stock code returned by FTShare."),
+    stock_name: s.string("Stock name."),
+};
+const reportFields = {
+    ...stockFields,
+    year: s.integer("Report year."),
+    report_type: s.string("Report period type."),
+    report_type_cn: s.string("Chinese report period name."),
+    publish_date: s.string("Publication date in YYYY-MM-DD format."),
+};
+function reportInput(allowHalfYear) {
+    return {
+        ...s.object("Choose either one stock's full history or a paginated market report period.", {
+            stock_code: s.string("Six-digit A-share code with exchange suffix, for example 000001.SZ. Returns all historical periods without pagination.", { pattern: "^[0-9]{6}\\.[A-Z]+$" }),
+            year: s.integer("Report year, required for market-wide queries."),
+            report_type: s.stringEnum("Report period: q1, q2 (half-year), q3, or annual. Income and balance sheets also accept h1 as q2.", allowHalfYear ? ["q1", "q2", "q3", "annual", "h1"] : ["q1", "q2", "q3", "annual"]),
+            page: s.integer("Market query page, starting at 1; defaults to 1.", { minimum: 1 }),
+            page_size: s.integer("Market query page size; defaults to 50, maximum 500.", {
+                minimum: 1,
+                maximum: 500,
+            }),
+        }, { required: [] }),
+        oneOf: [
+            {
+                required: ["stock_code"],
+                not: {
+                    anyOf: ["year", "report_type", "page", "page_size"].map((key) => ({ required: [key] })),
+                },
+            },
+            { required: ["year", "report_type"], not: { required: ["stock_code"] } },
+        ],
+    };
+}
+function envelope(data) {
+    return s.looseObject("FTShare response envelope; upstream extension fields are preserved.", {
+        code: s.integer("Upstream status code; 200 indicates success."),
+        message: s.string("Upstream status message."),
+        data,
+    });
+}
+function report(name, description, fields, allowHalfYear = false) {
+    return defineProviderAction("ftshare", {
+        name,
+        description,
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: reportInput(allowHalfYear),
+        outputSchema: envelope(s.looseObject("Report records and pagination totals.", {
+            items: s.array("Records, retaining financial strings, nulls, and additional upstream fields.", s.looseObject("One report record with provider-defined financial fields.", {
+                ...reportFields,
+                ...fields,
+            })),
+            total_items: s.integer("Total matching records."),
+            total_pages: s.integer("Total result pages."),
+        })),
+    });
+}
+export const ftshareActions = [
+    defineProviderAction("ftshare", {
+        name: "list_companies",
+        description: "List company snapshots with optional exact stock name and unsuffixed stock code filters.",
+        operationType: "read",
+        requiredScopes: [],
+        inputSchema: s.object("Company filters and pagination.", {
+            stock_code: s.nonEmptyString("Exact stock code without exchange suffix, for example 000001."),
+            stock_name: s.nonEmptyString("Exact stock name."),
+            page: s.integer("Page number; defaults to 1.", { minimum: 1 }),
+            page_size: s.integer("Page size; defaults to 50, maximum 200.", {
+                minimum: 1,
+                maximum: 200,
+            }),
+        }, { required: [] }),
+        outputSchema: envelope(s.looseObject("Company result page.", {
+            pageNum: s.integer("Current page number."),
+            pageSize: s.integer("Current page size."),
+            total: s.integer("Total matching companies."),
+            pages: s.integer("Total result pages."),
+            records: s.array("Company snapshots.", s.looseObject("Company details; additional upstream fields are preserved.", {
+                ...stockFields,
+                company_code: s.string("Company code."),
+                main_business: s.nullableString("Main business activities."),
+                company_profile: s.nullableString("Company profile."),
+                total_market_value: s.nullableString("Total market capitalization as reported by FTShare."),
+            })),
+        })),
+    }),
+    report("get_income_statements", "Read A-share income statements for one stock's full history or one market-wide report period.", {
+        report_form_type: s.string("Statement consolidation and adjustment type."),
+        t_revenue: s.nullableString("Total revenue."),
+        n_profit: s.nullableString("Net profit including minority interests."),
+        parcomp_n_profit: s.nullableString("Net profit attributable to the parent company."),
+    }, true),
+    report("get_balance_sheets", "Read A-share balance sheets for one stock's full history or one market-wide report period.", {
+        report_form_type: s.string("Statement consolidation and adjustment type."),
+        t_assets: s.nullableString("Total assets."),
+        t_liability: s.nullableString("Total liabilities."),
+        t_equity: s.nullableString("Total equity."),
+    }, true),
+    report("get_cashflow_statements", "Read A-share cash flow statements for one stock's full history or one market-wide report period.", {
+        detail_report_type: s.string("Detailed statement consolidation and adjustment type."),
+        net_oper_cash_flow: s.nullableString("Net cash flow from operating activities."),
+        net_invest_cash_flow: s.nullableString("Net cash flow from investing activities."),
+        net_fin_cash_flow: s.nullableString("Net cash flow from financing activities."),
+    }),
+    report("get_earnings_reports", "Read A-share earnings express reports by stock or market report period, preserving multiple disclosures and corrections.", {
+        eps: s.nullableString("Earnings per share."),
+        total_revenue: s.nullableString("Total revenue."),
+        net_profit: s.nullableString("Net profit."),
+        roe: s.nullableString("Return on equity."),
+    }),
+    report("get_earnings_forecasts", "Read A-share earnings forecasts by stock or market report period, including forecast ranges and year-over-year changes.", {
+        forecast_subject: s.string("Forecast financial metric."),
+        forecast_type: s.string("Forecast category reported by FTShare."),
+        forecast_value_min: s.nullableString("Lower forecast value."),
+        forecast_value_max: s.nullableString("Upper forecast value."),
+        unit: s.string("Forecast value unit."),
+        yoy_change_min: s.nullableString("Lower year-over-year percentage change."),
+        yoy_change_max: s.nullableString("Upper year-over-year percentage change."),
+        last_year_value: s.nullableString("Value for the same period last year."),
+    }),
+];

package/src/providers/ftshare/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/ftshare/executors.js

@@ -0,0 +1,102 @@
+import { optionalRecord, optionalRawString, optionalNumber } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { ftshareActions } from "./actions.js";
+const baseUrl = "https://market.ft.tech/gateway";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const routes = {
+    list_companies: "/api/v1/market/data/company-list",
+    get_income_statements: "/api/v1/market/data/finance/income",
+    get_balance_sheets: "/api/v1/market/data/finance/balance",
+    get_cashflow_statements: "/api/v1/market/data/finance/cashflow",
+    get_earnings_reports: "/api/v1/market/data/finance/stock-performance-express",
+    get_earnings_forecasts: "/api/v1/market/data/finance/stock-performance-forecast",
+};
+async function request({ route, input, apiKey, fetcher, parentSignal }) {
+    try {
+        return await runProviderRequest({ signal: parentSignal, label: "FTShare" }, async (signal) => {
+            const url = new URL(`${baseUrl}${route}`);
+            for (const [key, value] of Object.entries(input)) {
+                if (value != null)
+                    url.searchParams.set(key, String(value));
+            }
+            const response = await fetcher(url.toString(), {
+                method: "GET",
+                headers: { ...defaultHeaders, FTSHARE_API_KEY: apiKey },
+                signal,
+            });
+            const text = await response.text();
+            let payload;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                payload = undefined;
+            }
+            const body = optionalRecord(payload);
+            if (!response.ok || (body?.code != null && body.code !== 200)) {
+                const code = optionalRawString(body?.code) ?? optionalNumber(body?.code);
+                const detail = [
+                    code,
+                    optionalRawString(body?.msg),
+                    optionalRawString(body?.message),
+                    optionalRawString(optionalRecord(body?.data)?.reason),
+                ]
+                    .filter((value) => value != null && value !== "")
+                    .join(": ") || `HTTP ${response.status}`;
+                throw new ProviderRequestError(response.ok ? 502 : response.status, `FTShare request failed: ${detail}`, undefined, response.status === 429 ? "rate_limited" : "provider_error");
+            }
+            return requiredResponseRecord(payload, "FTShare response");
+        });
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError)
+            error.message = error.message.split(apiKey).join("[REDACTED]");
+        throw error;
+    }
+}
+const handlers = mapProviderActionHandlers("ftshare", ftshareActions, (action) => async (dataInput, context) => {
+    const route = routes[action.name];
+    const query = { ...dataInput };
+    if (action.name === "list_companies" || query.stock_code == null) {
+        query.page ??= 1;
+        query.page_size ??= 50;
+    }
+    if (query.report_type === "h1")
+        query.report_type = "q2";
+    return request({
+        route: route,
+        input: query,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("ftshare", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request({
+            route: routes.list_companies,
+            input: { page: 1, page_size: 1 },
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        return { profile: { displayName: "FTShare API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "ftshare",
+    baseUrl,
+    auth: { type: "api_key_header", name: "FTSHARE_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/providers/fundable/actions.d.ts

@@ -0,0 +1,8 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const fundableActions: ActionDefinition[];
+interface FundableRoute {
+    method: "GET" | "POST";
+    path: string;
+}
+export declare const fundableRoutes: Record<string, FundableRoute>;
+export {};