@oomol-lab/open-connector 1.9.1 → 1.9.2

package/src/providers/tinyfish/research-schemas.js

@@ -0,0 +1,71 @@
+import { s } from "../../core/json-schema.js";
+export const researchStatus = s.stringEnum("Research run state.", [
+    "RUNNING",
+    "COMPLETED",
+    "FAILED",
+    "CANCELLED",
+    "TIMED_OUT",
+    "QUEUED",
+]);
+export const researchId = s.string("Research run identifier.", { minLength: 1 });
+export const researchInput = {
+    ...s.object("Asynchronous research parameters.", {
+        query: s.string("Research question.", { minLength: 1, maxLength: 2000 }),
+        mode: s.stringEnum("Research depth; defaults to deep.", ["deep", "max"]),
+        stream: s.boolean("Emit report text as synthesis events upstream; results are retrieved through get_research_run."),
+        output_language: s.string("BCP 47 report language."),
+        weak_sources_enabled: s.boolean("Allow relevant social and community sources."),
+        domain_type: s.stringEnum("Source pool.", ["web", "news", "research_paper"]),
+        after_date: s.string("Include results on or after this date.", { format: "date" }),
+        before_date: s.string("Include results on or before this date.", { format: "date" }),
+        recency_minutes: s.integer("Freshness window; cannot combine with date filters.", {
+            minimum: 1,
+            maximum: 5256000,
+        }),
+        domain_filter: s.object("Domain preferences.", {
+            mode: s.stringEnum("Prioritize domains or restrict results exclusively to them.", ["include", "exclusive"]),
+            domains: s.array("Domains to prefer or require.", s.string("Domain."), { maxItems: 150 }),
+            block: s.array("Domains to exclude.", s.string("Domain."), { maxItems: 150 }),
+        }, { required: ["mode"] }),
+        prior_run_id: s.string("Completed report and evidence to reuse; mutually exclusive with session_id."),
+        session_id: s.string("Research session to continue; mutually exclusive with prior_run_id.", {
+            format: "uuid",
+        }),
+    }, { required: ["query"] }),
+    not: {
+        anyOf: [
+            { required: ["prior_run_id", "session_id"] },
+            { required: ["recency_minutes", "after_date"] },
+            { required: ["recency_minutes", "before_date"] },
+        ],
+    },
+};
+export const researchListInput = s.object("Research filters and cursor.", {
+    status: researchStatus,
+    query: s.string("Case-insensitive partial query filter.", { maxLength: 500 }),
+    created_after: s.string("Created after timestamp.", { format: "date-time" }),
+    created_before: s.string("Created before timestamp.", { format: "date-time" }),
+    sort_direction: s.stringEnum("Creation time sort order; defaults to desc.", ["asc", "desc"]),
+    cursor: s.string("Pagination cursor; replay with the same sort_direction."),
+    limit: s.integer("Maximum returned records.", { minimum: 1, maximum: 100 }),
+}, { required: [] });
+export const researchOutput = s.looseObject("Research status, reports and evidence.", {
+    research_run_id: researchId,
+    status: researchStatus,
+    query: s.string("Research question."),
+    quick_result: s.nullable(s.looseObject("Quick answer, citations and optional progress.")),
+    quick_result_summary: s.nullable(s.string("Quick answer summary.")),
+    deep_result: s.nullable(s.looseObject("Final report.", {
+        result: s.string("Report text."),
+        citations: s.array("Cited sources.", s.string("Source URL.")),
+        freshness_report: s.looseObject("Source freshness information."),
+        termination_reason: s.string("Reason research stopped; synthesis_failed indicates interim findings."),
+    })),
+    run_ids: s.array("Spawned agent run identifiers.", s.string("Agent run identifier.")),
+    created_at: s.nullable(s.string("Creation timestamp.")),
+    completed_at: s.nullable(s.string("Completion timestamp.")),
+    error: s.nullable(s.looseObject("Saved terminal outcome, not an HTTP request error.")),
+    research_plan: s.nullable(s.looseObject("Subquestions and planned searches.")),
+    evidence: s.nullable(s.array("Sources and supported claims.", s.looseObject("Evidence source."))),
+    iterations: s.nullable(s.integer("Completed research iterations.", { minimum: 0 })),
+});

package/src/providers/trello/executors.js

@@ -1,3 +1,4 @@
+import { encodeRfc3986 } from "../../core/aws-sigv4.js";
 import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, requireCustomCredential, toProviderProxyError, } from "../provider-runtime.js";
 import { trelloActionHandlers, trelloApiBaseUrl, validateTrelloCredential } from "./runtime.js";
 const service = "trello";
@@ -23,9 +24,11 @@ export const proxy = async (input, context) => {
     try {
         const credential = await requireCustomCredential(context, service);
         const url = createProviderProxyUrl(trelloApiBaseUrl, input.endpoint, input.query);
-        url.searchParams.set("key", credential.values.apiKey);
-        url.searchParams.set("token", credential.values.apiToken);
+        url.searchParams.delete("key");
+        url.searchParams.delete("token");
         const headers = normalizeProviderProxyHeaders(input.headers);
+        // Trello attachment downloads require header authentication, unlike metadata reads.
+        headers.set("authorization", `OAuth oauth_consumer_key="${encodeRfc3986(credential.values.apiKey)}", oauth_token="${encodeRfc3986(credential.values.apiToken)}"`);
         headers.set("user-agent", providerUserAgent);
         const init = {
             method: input.method,

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

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/typeform/executors.js

@@ -1,5 +1,6 @@
 import { defineBearerProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
 import { fetchTypeformCurrentAccount, typeformActionHandlers, typeformApiBaseUrl, validateTypeformCredential, } from "./runtime.js";
+import { typeformResponse } from "./trigger-on-form-response.js";
 const service = "typeform";
 export const executors = defineBearerProviderExecutors(service, typeformActionHandlers);
 export const proxy = defineProviderProxy({
@@ -15,3 +16,4 @@ export const credentialValidators = {
         return fetchTypeformCurrentAccount(input.accessToken, fetcher, signal);
     },
 };
+export const triggers = [typeformResponse];

package/src/providers/typeform/trigger-on-form-response.d.ts

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

package/src/providers/typeform/trigger-on-form-response.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/typeform/trigger-on-form-response.definition.js

@@ -0,0 +1,40 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    key: "typeform.on_form_response",
+    provider: "typeform",
+    name: "on_form_response",
+    displayName: "Completed Form Response",
+    description: "Receives complete Typeform submissions through an automatically managed signed webhook.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "formId",
+            jsonSchema: { type: "string", minLength: 1, maxLength: 128, title: "Form ID" },
+            nullable: false,
+        },
+    ],
+    outputs: [
+        {
+            handle: "response",
+            nullable: false,
+            jsonSchema: {
+                type: "object",
+                properties: {
+                    eventId: s.string(),
+                    form_id: s.string(),
+                    token: s.string(),
+                    submitted_at: s.string(),
+                    answers: { type: "array", items: { type: "object" } },
+                    definition: { type: "object" },
+                },
+                required: ["eventId", "form_id", "token", "submitted_at", "answers"],
+            },
+        },
+    ],
+};

package/src/providers/typeform/trigger-on-form-response.js

@@ -0,0 +1,68 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { bytes, verifyBase64Hmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-form-response.definition.js";
+export const typeformResponse = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        if (context.state == null)
+            throw new PermanentIntegrationError("Typeform subscription state is missing.");
+        const formId = context.config.formId;
+        if (typeof formId != "string" || !formId)
+            throw new PermanentIntegrationError("Choose a Typeform form.");
+        // A stable tag makes retries update the same webhook after a lost response.
+        const hash = await crypto.subtle.digest("SHA-256", bytes(context.endpointUrl));
+        const tag = `oomol-${Array.from(new Uint8Array(hash), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+        const endpoint = `/forms/${encodeURIComponent(formId)}/webhooks/${tag}`;
+        context.signal?.throwIfAborted();
+        const result = await context.connector.execute({
+            endpoint,
+            method: context.active ? "PUT" : "DELETE",
+            body: context.active
+                ? {
+                    url: context.endpointUrl,
+                    enabled: true,
+                    secret: context.callbackSecret,
+                    event_types: { form_response: true, form_response_partial: false },
+                }
+                : undefined,
+        }, context.signal);
+        context.signal?.throwIfAborted();
+        if (!(result.status >= 200 && result.status < 300) && !(!context.active && result.status == 404)) {
+            const message = `Typeform webhook operation failed (HTTP ${result.status}). Check form access and webhook permissions.`;
+            if (result.status >= 400 && result.status < 500 && result.status != 429)
+                throw new PermanentIntegrationError(message);
+            throw new TransientIntegrationError(message);
+        }
+        await context.state.saveSubscription(context.active ? { tag } : {}, new Date(context.now.getTime() + 24 * 60 * 60 * 1000));
+        return { outcome: "ready" };
+    },
+    async receive(context) {
+        const signature = context.header("typeform-signature");
+        if (!signature?.startsWith("sha256=") ||
+            !(await verifyBase64Hmac(context.callbackSecret, [context.rawBody], signature.slice(7))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const payload = context.payload;
+        if (!isJsonObject(payload) || payload.event_type != "form_response")
+            return { outcome: "ignored", reason: "Only complete form responses are supported." };
+        const response = payload.form_response;
+        if (!isJsonObject(response) || response.form_id != context.config.formId)
+            return { outcome: "ignored", reason: "Typeform form does not match this subscription." };
+        if (typeof payload.event_id != "string" ||
+            !payload.event_id ||
+            typeof response.token != "string" ||
+            !response.token ||
+            typeof response.submitted_at != "string" ||
+            !response.submitted_at ||
+            !Array.isArray(response.answers) ||
+            response.answers.some((answer) => !isJsonObject(answer)) ||
+            ("definition" in response && !isJsonObject(response.definition)))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: response.token,
+            outputs: { response: { ...response, eventId: payload.event_id } },
+        };
+    },
+};

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

@@ -0,0 +1,13 @@
+import type { ActionDefinition } from "../../core/types.ts";
+interface VaquillOperation {
+    name: string;
+    method: string;
+    path: string;
+    query: string[];
+    pathKeys: string[];
+    action: ActionDefinition;
+}
+declare const vaquillOperations: readonly VaquillOperation[];
+export declare const vaquillActions: ActionDefinition[];
+export declare const vaquillOperationByName: Map<string, (typeof vaquillOperations)[number]>;
+export {};