unify codegen for superagent (#97)

Author: ctate

lib/codegen-registry.ts

@@ -7,7 +7,7 @@
  * Contains auto-generated codegen templates for steps with stepHandler.
  * These templates are used when exporting workflows to standalone projects.
  *
- * Generated templates: 10
+ * Generated templates: 12
  */
 
 /**
@@ -567,6 +567,162 @@ export async function sendSlackMessageStep(
     };
   }
 }
+`,
+
+  "superagent/guard": `import { fetchCredentials } from "./lib/credential-helper";
+
+function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+type GuardResult = {
+  classification: GuardClassification;
+  violationTypes: string[];
+  cweCodes: string[];
+  reasoning?: string;
+};
+
+export type SuperagentGuardCoreInput = {
+  text: string;
+};
+
+export async function superagentGuardStep(
+  input: SuperagentGuardCoreInput,
+): Promise<GuardResult> {
+  "use step";
+  const credentials = await fetchCredentials("superagent");
+  const apiKey = credentials.SUPERAGENT_API_KEY;
+
+  if (!apiKey) {
+    throw new Error("Superagent API Key is not configured.");
+  }
+
+  try {
+    const response = await fetch("https://app.superagent.sh/api/guard", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: \`Bearer \${apiKey}\`,
+      },
+      body: JSON.stringify({
+        text: input.text,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(\`Guard API error: \${error}\`);
+    }
+
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    const content = choice?.message?.content;
+
+    if (!content || typeof content !== "object") {
+      throw new Error(
+        "Invalid Guard API response: missing or invalid content structure",
+      );
+    }
+
+    const classification = content.classification;
+    if (
+      !classification ||
+      (classification !== "allow" && classification !== "block")
+    ) {
+      throw new Error(
+        \`Invalid Guard API response: missing or invalid classification (received: \${JSON.stringify(classification)})\`,
+      );
+    }
+
+    return {
+      classification,
+      violationTypes: content?.violation_types || [],
+      cweCodes: content?.cwe_codes || [],
+      reasoning: choice?.message?.reasoning,
+    };
+  } catch (error) {
+    throw new Error(\`Failed to analyze text: \${getErrorMessage(error)}\`);
+  }
+}
+`,
+
+  "superagent/redact": `import { fetchCredentials } from "./lib/credential-helper";
+
+function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+type RedactResult = {
+  redactedText: string;
+  reasoning?: string;
+};
+
+export type SuperagentRedactCoreInput = {
+  text: string;
+  entities?: string[] | string;
+};
+
+export async function superagentRedactStep(
+  input: SuperagentRedactCoreInput,
+): Promise<RedactResult> {
+  "use step";
+  const credentials = await fetchCredentials("superagent");
+  const apiKey = credentials.SUPERAGENT_API_KEY;
+
+  if (!apiKey) {
+    throw new Error("Superagent API Key is not configured.");
+  }
+
+  try {
+    const body: { text: string; entities?: string[] } = {
+      text: input.text,
+    };
+
+    if (input.entities) {
+      let entitiesArray: string[];
+
+      if (typeof input.entities === "string") {
+        entitiesArray = input.entities.split(",").map((e) => e.trim());
+      } else if (Array.isArray(input.entities)) {
+        entitiesArray = input.entities.map((e) => String(e).trim());
+      } else {
+        entitiesArray = [];
+      }
+
+      const validEntities = entitiesArray.filter((e) => e.length > 0);
+
+      if (validEntities.length > 0) {
+        body.entities = validEntities;
+      }
+    }
+
+    const response = await fetch("https://app.superagent.sh/api/redact", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: \`Bearer \${apiKey}\`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(\`Redact API error: \${error}\`);
+    }
+
+    const data = await response.json();
+    const choice = data.choices?.[0];
+
+    return {
+      redactedText: choice?.message?.content || input.text,
+      reasoning: choice?.message?.reasoning,
+    };
+  } catch (error) {
+    throw new Error(\`Failed to redact text: \${getErrorMessage(error)}\`);
+  }
+}
 `,
 
   "v0/create-chat": `import { createClient, type ChatsCreateResponse } from "v0-sdk";

plugins/superagent/codegen/guard.ts

@@ -0,0 +1,4 @@
+export type SuperagentCredentials = {
+  SUPERAGENT_API_KEY?: string;
+};
+

plugins/superagent/codegen/redact.ts

@@ -1,7 +1,5 @@
 import type { IntegrationPlugin } from "../registry";
 import { registerIntegration } from "../registry";
-import { guardCodegenTemplate } from "./codegen/guard";
-import { redactCodegenTemplate } from "./codegen/redact";
 import { SuperagentIcon } from "./icon";
 
 const superagentPlugin: IntegrationPlugin = {
@@ -54,7 +52,6 @@ const superagentPlugin: IntegrationPlugin = {
           rows: 4,
         },
       ],
-      codegenTemplate: guardCodegenTemplate,
     },
     {
       slug: "redact",
@@ -82,7 +79,6 @@ const superagentPlugin: IntegrationPlugin = {
           example: "",
         },
       ],
-      codegenTemplate: redactCodegenTemplate,
     },
   ],
 };

plugins/superagent/credentials.ts

@@ -3,6 +3,7 @@ import "server-only";
 import { fetchCredentials } from "@/lib/credential-fetcher";
 import { type StepInput, withStepLogging } from "@/lib/steps/step-handler";
 import { getErrorMessage } from "@/lib/utils";
+import type { SuperagentCredentials } from "../credentials";
 
 type GuardClassification = "allow" | "block";
 
@@ -13,19 +14,22 @@ type GuardResult = {
   reasoning?: string;
 };
 
-export type SuperagentGuardInput = StepInput & {
-  integrationId?: string;
+export type SuperagentGuardCoreInput = {
   text: string;
 };
 
+export type SuperagentGuardInput = StepInput &
+  SuperagentGuardCoreInput & {
+    integrationId?: string;
+  };
+
 /**
- * Guard logic - analyzes text for security threats
+ * Core logic
  */
-async function guard(input: SuperagentGuardInput): Promise<GuardResult> {
-  const credentials = input.integrationId
-    ? await fetchCredentials(input.integrationId)
-    : {};
-
+async function stepHandler(
+  input: SuperagentGuardCoreInput,
+  credentials: SuperagentCredentials
+): Promise<GuardResult> {
   const apiKey = credentials.SUPERAGENT_API_KEY;
 
   if (!apiKey) {
@@ -53,15 +57,17 @@ async function guard(input: SuperagentGuardInput): Promise<GuardResult> {
     const choice = data.choices?.[0];
     const content = choice?.message?.content;
 
-    // Validate response structure - fail safe instead of defaulting to "allow"
     if (!content || typeof content !== "object") {
       throw new Error(
         "Invalid Guard API response: missing or invalid content structure"
       );
     }
 
     const classification = content.classification;
-    if (!classification || (classification !== "allow" && classification !== "block")) {
+    if (
+      !classification ||
+      (classification !== "allow" && classification !== "block")
+    ) {
       throw new Error(
         `Invalid Guard API response: missing or invalid classification (received: ${JSON.stringify(classification)})`
       );
@@ -79,12 +85,18 @@ async function guard(input: SuperagentGuardInput): Promise<GuardResult> {
 }
 
 /**
- * Superagent Guard Step
- * Analyzes text for security threats like prompt injection
+ * Step entry point
  */
 export async function superagentGuardStep(
   input: SuperagentGuardInput
 ): Promise<GuardResult> {
   "use step";
-  return withStepLogging(input, () => guard(input));
+
+  const credentials = input.integrationId
+    ? await fetchCredentials(input.integrationId)
+    : {};
+
+  return withStepLogging(input, () => stepHandler(input, credentials));
 }
+
+export const _integrationType = "superagent";