@pipedream/strale 0.0.1 → 0.1.0

package/actions/execute-capability/execute-capability.mjs

@@ -0,0 +1,79 @@
+import strale from "../../strale.app.mjs";
+
+export default {
+  name: "Execute Capability",
+  version: "0.0.1",
+  key: "strale-execute-capability",
+  description: "Execute a specific Strale capability by slug with the provided inputs. Returns structured data with quality score and audit trail. [See the documentation](https://strale.dev/docs)",
+  type: "action",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
+  props: {
+    strale,
+    capabilitySlug: {
+      propDefinition: [
+        strale,
+        "capabilitySlug",
+      ],
+    },
+    inputs: {
+      propDefinition: [
+        strale,
+        "inputs",
+      ],
+    },
+    maxPriceCents: {
+      propDefinition: [
+        strale,
+        "maxPriceCents",
+      ],
+    },
+    dryRun: {
+      propDefinition: [
+        strale,
+        "dryRun",
+      ],
+    },
+  },
+  async run({ $ }) {
+    // Pipedream's object-type prop is usually parsed to a JS object, but
+    // can arrive as a string if the user pasted raw JSON in the UI. Coerce
+    // defensively so `/v1/do` receives an object as the API expects.
+    let parsedInputs = this.inputs;
+    if (typeof parsedInputs === "string") {
+      try {
+        parsedInputs = JSON.parse(parsedInputs);
+      } catch {
+        throw new Error(
+          "The \"Inputs\" field must be a valid JSON object (e.g. {\"email\": \"ops@example.com\"}).",
+        );
+      }
+    }
+
+    const data = {
+      capability_slug: this.capabilitySlug,
+      inputs: parsedInputs ?? {},
+      max_price_cents: this.maxPriceCents,
+    };
+
+    if (this.dryRun) {
+      data.dry_run = true;
+    }
+
+    const response = await this.strale.execute({
+      $,
+      data,
+    });
+
+    if (this.dryRun) {
+      $.export("$summary", `Dry run matched capability "${response.capability?.slug ?? this.capabilitySlug}"`);
+    } else {
+      $.export("$summary", `Successfully executed "${this.capabilitySlug}" (transaction: ${response?.result?.transaction_id ?? "n/a"})`);
+    }
+
+    return response;
+  },
+};

package/actions/search-and-execute/search-and-execute.mjs

@@ -0,0 +1,82 @@
+import strale from "../../strale.app.mjs";
+
+export default {
+  name: "Search and Execute",
+  version: "0.0.1",
+  key: "strale-search-and-execute",
+  description: "Describe what you need in plain language \u2014 Strale picks the best capability and executes it in one step. Use this when you don't know the exact capability slug. If you already know the slug, use **Execute Capability** instead; if you only want to discover matches without running anything, use **Search Capabilities**. [See the documentation](https://strale.dev/docs)",
+  type: "action",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
+  props: {
+    strale,
+    task: {
+      propDefinition: [
+        strale,
+        "task",
+      ],
+    },
+    inputs: {
+      propDefinition: [
+        strale,
+        "inputs",
+      ],
+      optional: true,
+    },
+    maxPriceCents: {
+      propDefinition: [
+        strale,
+        "maxPriceCents",
+      ],
+    },
+    dryRun: {
+      propDefinition: [
+        strale,
+        "dryRun",
+      ],
+    },
+  },
+  async run({ $ }) {
+    // Pipedream's object-type prop is usually parsed to a JS object, but
+    // can arrive as a string if the user pasted raw JSON in the UI. Coerce
+    // defensively so `/v1/do` receives an object as the API expects.
+    let parsedInputs = this.inputs;
+    if (typeof parsedInputs === "string") {
+      try {
+        parsedInputs = JSON.parse(parsedInputs);
+      } catch {
+        throw new Error(
+          "The \"Inputs\" field must be a valid JSON object (e.g. {\"email\": \"ops@example.com\"}).",
+        );
+      }
+    }
+
+    const data = {
+      task: this.task,
+      inputs: parsedInputs ?? {},
+      max_price_cents: this.maxPriceCents,
+    };
+
+    if (this.dryRun) {
+      data.dry_run = true;
+      const response = await this.strale.execute({
+        $,
+        data,
+      });
+      $.export("$summary", `Dry run completed for "${this.task}"`);
+      return response;
+    }
+
+    const response = await this.strale.execute({
+      $,
+      data,
+    });
+
+    $.export("$summary", `Executed "${this.task}" (transaction: ${response?.result?.transaction_id ?? "n/a"})`);
+
+    return response;
+  },
+};

package/actions/search-capabilities/search-capabilities.mjs

@@ -0,0 +1,42 @@
+import strale from "../../strale.app.mjs";
+
+export default {
+  name: "Search Capabilities",
+  version: "0.0.1",
+  key: "strale-search-capabilities",
+  description: "Search Strale's catalog of 290+ data capabilities using natural language. Returns matching capabilities with prices and quality scores. [See the documentation](https://strale.dev/docs)",
+  type: "action",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+  },
+  props: {
+    strale,
+    task: {
+      propDefinition: [
+        strale,
+        "task",
+      ],
+    },
+    limit: {
+      propDefinition: [
+        strale,
+        "limit",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.strale.suggest({
+      $,
+      data: {
+        query: this.task,
+        limit: this.limit ?? 5,
+      },
+    });
+
+    $.export("$summary", `Successfully searched for matching capabilities for "${this.task}"`);
+
+    return response;
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/strale",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream Strale Components",
   "main": "strale.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^3.1.1"
   }
 }

package/strale.app.mjs

@@ -1,11 +1,121 @@
+import { axios } from "@pipedream/platform";
+
 export default {
   type: "app",
   app: "strale",
-  propDefinitions: {},
+  description: "Strale is the data layer for AI agents — 290+ quality-tested data capabilities including company verification, sanctions screening, VAT validation, invoice extraction, and more. [See the documentation](https://strale.dev/docs)",
+  propDefinitions: {
+    task: {
+      type: "string",
+      label: "Task",
+      description: "A natural-language description of what you need (e.g. \"verify a Swedish company\", \"validate this VAT number\").",
+    },
+    capabilitySlug: {
+      type: "string",
+      label: "Capability Slug",
+      description: "The slug of the capability to execute (e.g. `swedish-company-data`, `vat-validate`, `email-validate`). [See the catalog](https://strale.dev).",
+    },
+    inputs: {
+      type: "object",
+      label: "Inputs",
+      description: "Input parameters for the capability as a JSON object (e.g. `{ \"vat_number\": \"SE556677889901\" }` or `{ \"email\": \"ops@example.com\" }`). The required fields depend on the capability being called.",
+    },
+    limit: {
+      type: "integer",
+      label: "Limit",
+      description: "Maximum number of results to return.",
+      optional: true,
+      default: 5,
+    },
+    maxPriceCents: {
+      type: "integer",
+      label: "Max Price (cents)",
+      description: "Maximum price in euro cents you are willing to pay per execution.",
+      optional: true,
+    },
+    dryRun: {
+      type: "boolean",
+      label: "Dry Run",
+      description: "If `true`, validates the request and returns the matched capability without executing or charging.",
+      optional: true,
+      default: false,
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    _apiKey() {
+      return this.$auth.api_key;
+    },
+    _baseUrl() {
+      return "https://api.strale.io";
+    },
+    _headers() {
+      const headers = {
+        "Content-Type": "application/json",
+      };
+      const apiKey = this._apiKey();
+      if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      return headers;
+    },
+    async _makeRequest({
+      $ = this, path, headers = {}, ...args
+    }) {
+      try {
+        return await axios($, {
+          url: `${this._baseUrl()}${path}`,
+          ...args,
+          headers: {
+            ...this._headers(),
+            ...headers,
+          },
+        });
+      } catch (err) {
+        // The Strale API returns HTTP 500 with a structured body for
+        // execution-level failures (missing input fields, capability
+        // timeouts, etc.). axios throws on non-2xx — without this catch,
+        // Pipedream surfaces it as a generic "Internal server error".
+        // Re-throw with the actual message + error_code so the workflow
+        // UI shows something actionable.
+        const data = err.response?.data;
+        const message = data?.message ?? data?.error_code ?? err.message;
+        const code = data?.error_code
+          ? ` (${data.error_code})`
+          : "";
+        const status = err.response?.status ?? "";
+        const statusLabel = status
+          ? ` [HTTP ${status}]`
+          : "";
+        throw new Error(`Strale API error${statusLabel}${code}: ${message}`);
+      }
+    },
+    suggest(args = {}) {
+      return this._makeRequest({
+        path: "/v1/suggest",
+        method: "post",
+        ...args,
+      });
+    },
+    execute(args = {}) {
+      return this._makeRequest({
+        path: "/v1/do",
+        method: "post",
+        ...args,
+      });
+    },
+    listCapabilities(args = {}) {
+      return this._makeRequest({
+        path: "/v1/capabilities",
+        ...args,
+      });
+    },
+    getQuality({
+      slug, ...args
+    } = {}) {
+      return this._makeRequest({
+        path: `/v1/quality/${slug}`,
+        ...args,
+      });
     },
   },
-};
+};