@devosurf/tesser-connectors 0.1.0-alpha.0

package/google-drive/index.ts

@@ -0,0 +1,265 @@
+// Google Drive connector — third connector behind the shared `google` Provider (one
+// OAuth app backs gmail + google-calendar + google-drive). Ships least-privilege:
+// drive.file is NON-SENSITIVE (per-file: only files the app created or the user opened
+// with it). Listing/searching the whole Drive, or a changes feed over arbitrary files,
+// needs the broader RESTRICTED `drive`/`drive.readonly` scope (security assessment).
+
+import { z } from "zod";
+import { action, defineConnector, oauth2, trigger, type ActionCtx } from "@devosurf/tesser-sdk/connector";
+import { googleProvider } from "../providers/google.js";
+
+const FOLDER_MIME = "application/vnd.google-apps.folder";
+// fields projection shared by list/get/create/copy — keeps responses to our stable shape.
+const FILE_FIELDS = "id,name,mimeType,modifiedTime,webViewLink";
+const LIST_PAGE_CAP = 10;
+
+const fileShape = z.object({
+  id: z.string(),
+  name: z.string(),
+  mimeType: z.string(),
+  modifiedTime: z.string(),
+  webViewLink: z.string().optional(),
+});
+
+type RawFile = {
+  id: string;
+  name?: string;
+  mimeType?: string;
+  modifiedTime?: string;
+  webViewLink?: string;
+};
+
+function mapFile(raw: RawFile): z.infer<typeof fileShape> {
+  return {
+    id: raw.id,
+    name: raw.name ?? "",
+    mimeType: raw.mimeType ?? "",
+    modifiedTime: raw.modifiedTime ?? "",
+    ...(raw.webViewLink !== undefined ? { webViewLink: raw.webViewLink } : {}),
+  };
+}
+
+// One files.list page. Caller owns the pageToken loop (no built-in paginator).
+async function listPage(
+  ctx: ActionCtx,
+  params: { q?: string; pageSize: number; orderBy?: string; pageToken?: string },
+): Promise<{ files: RawFile[]; nextPageToken?: string }> {
+  const res = (await ctx.http.get("/files", {
+    query: {
+      fields: `nextPageToken,files(${FILE_FIELDS})`,
+      pageSize: params.pageSize,
+      ...(params.q !== undefined ? { q: params.q } : {}),
+      ...(params.orderBy !== undefined ? { orderBy: params.orderBy } : {}),
+      ...(params.pageToken !== undefined ? { pageToken: params.pageToken } : {}),
+    },
+  })) as { files?: RawFile[]; nextPageToken?: string };
+  return {
+    files: res.files ?? [],
+    ...(res.nextPageToken !== undefined ? { nextPageToken: res.nextPageToken } : {}),
+  };
+}
+
+export default defineConnector({
+  id: "google-drive",
+  describe: "Google Drive — list, fetch, create, copy, and share app-created or user-opened files",
+  provider: googleProvider,
+  baseUrl: "https://www.googleapis.com/drive/v3",
+  auth: oauth2({
+    provider: "google",
+    // drive.file is NON-SENSITIVE and least-privilege (app-created / user-opened files).
+    // A "list everything" connector would need the RESTRICTED `drive` scope.
+    scopes: ["https://www.googleapis.com/auth/drive.file"],
+  }),
+  // Drive has NO idempotency header, so writes (createFolder/copy/delete/permissions.create)
+  // do not auto-retry — correct for non-idempotent operations.
+  samples: {
+    "files.list": [
+      {
+        id: "1AbCfile",
+        name: "Quarterly report.pdf",
+        mimeType: "application/pdf",
+        modifiedTime: "2026-01-01T00:00:00.000Z",
+        webViewLink: "https://drive.google.com/file/d/1AbCfile/view",
+      },
+    ],
+    "files.get": {
+      id: "1AbCfile",
+      name: "Quarterly report.pdf",
+      mimeType: "application/pdf",
+      modifiedTime: "2026-01-01T00:00:00.000Z",
+      webViewLink: "https://drive.google.com/file/d/1AbCfile/view",
+    },
+    "files.createFolder": {
+      id: "1FolderId",
+      name: "Invoices",
+      mimeType: FOLDER_MIME,
+      modifiedTime: "2026-01-01T00:00:00.000Z",
+      webViewLink: "https://drive.google.com/drive/folders/1FolderId",
+    },
+    "files.copy": {
+      id: "1CopyId",
+      name: "Quarterly report (copy).pdf",
+      mimeType: "application/pdf",
+      modifiedTime: "2026-01-02T00:00:00.000Z",
+      webViewLink: "https://drive.google.com/file/d/1CopyId/view",
+    },
+    "files.delete": { id: "1AbCfile", deleted: true },
+    "permissions.create": { id: "perm123", role: "reader", type: "user" },
+    "trigger:newFileInFolder": {
+      id: "1NewFile",
+      name: "uploaded.csv",
+      mimeType: "text/csv",
+      modifiedTime: "2026-01-03T00:00:00.000Z",
+      webViewLink: "https://drive.google.com/file/d/1NewFile/view",
+    },
+  },
+  actions: {
+    files: {
+      list: action({
+        describe: "List/search files visible to the app with a raw Drive q query (loops pages, ~10-page cap)",
+        input: z.object({
+          q: z.string().optional(),
+          pageSize: z.number().int().min(1).max(100).default(100),
+        }),
+        output: z.array(fileShape),
+        safety: "read",
+        run: async (ctx, i) => {
+          const out: RawFile[] = [];
+          let pageToken: string | undefined;
+          for (let page = 0; page < LIST_PAGE_CAP; page++) {
+            const res = await listPage(ctx, {
+              pageSize: i.pageSize,
+              ...(i.q !== undefined ? { q: i.q } : {}),
+              ...(pageToken !== undefined ? { pageToken } : {}),
+            });
+            out.push(...res.files);
+            if (res.nextPageToken === undefined) break;
+            pageToken = res.nextPageToken;
+          }
+          return out.map(mapFile);
+        },
+      }),
+      get: action({
+        describe: "Fetch one file's metadata",
+        input: z.object({ fileId: z.string().min(1) }),
+        output: fileShape,
+        safety: "read",
+        run: async (ctx, i) => {
+          const res = (await ctx.http.get(`/files/${encodeURIComponent(i.fileId)}`, {
+            query: { fields: FILE_FIELDS },
+          })) as RawFile;
+          return mapFile(res);
+        },
+      }),
+      createFolder: action({
+        describe: "Create a folder (optionally under a parent folder)",
+        input: z.object({
+          name: z.string().min(1),
+          parents: z.array(z.string()).optional(),
+        }),
+        output: fileShape,
+        run: async (ctx, i) => {
+          const res = (await ctx.http.post(
+            "/files",
+            {
+              name: i.name,
+              mimeType: FOLDER_MIME,
+              ...(i.parents !== undefined ? { parents: i.parents } : {}),
+            },
+            { query: { fields: FILE_FIELDS } },
+          )) as RawFile;
+          return mapFile(res);
+        },
+      }),
+      copy: action({
+        describe: "Copy a file (no folder recursion; optionally rename/reparent)",
+        input: z.object({
+          fileId: z.string().min(1),
+          name: z.string().optional(),
+          parents: z.array(z.string()).optional(),
+        }),
+        output: fileShape,
+        run: async (ctx, i) => {
+          const res = (await ctx.http.post(
+            `/files/${encodeURIComponent(i.fileId)}/copy`,
+            {
+              ...(i.name !== undefined ? { name: i.name } : {}),
+              ...(i.parents !== undefined ? { parents: i.parents } : {}),
+            },
+            { query: { fields: FILE_FIELDS } },
+          )) as RawFile;
+          return mapFile(res);
+        },
+      }),
+      delete: action({
+        describe: "Permanently delete a file (cascades on folders, irreversible)",
+        input: z.object({ fileId: z.string().min(1) }),
+        output: z.object({ id: z.string(), deleted: z.literal(true) }),
+        run: async (ctx, i) => {
+          // DELETE returns 204 with an empty body.
+          await ctx.http.delete(`/files/${encodeURIComponent(i.fileId)}`);
+          return { id: i.fileId, deleted: true as const };
+        },
+      }),
+    },
+    permissions: {
+      create: action({
+        describe: "Grant a permission on a file (share with a user/group/domain/anyone)",
+        input: z.object({
+          fileId: z.string().min(1),
+          role: z.enum([
+            "reader",
+            "commenter",
+            "writer",
+            "fileOrganizer",
+            "organizer",
+            "owner",
+          ]),
+          type: z.enum(["user", "group", "domain", "anyone"]),
+          emailAddress: z.string().optional(),
+        }),
+        output: z.object({
+          id: z.string(),
+          role: z.string(),
+          type: z.string(),
+        }),
+        run: async (ctx, i) => {
+          const res = (await ctx.http.post(
+            `/files/${encodeURIComponent(i.fileId)}/permissions`,
+            {
+              role: i.role,
+              type: i.type,
+              ...(i.emailAddress !== undefined ? { emailAddress: i.emailAddress } : {}),
+            },
+            { query: { fields: "id,role,type" } },
+          )) as { id: string; role?: string; type?: string };
+          return { id: res.id, role: res.role ?? i.role, type: res.type ?? i.type };
+        },
+      }),
+    },
+  },
+  triggers: {
+    newFileInFolder: trigger.poll({
+      describe: "Fires for each new app-accessible file added to a folder (optionally filtered by mimeType)",
+      input: z.object({
+        folderId: z.string().min(1),
+        q: z.string().optional(),
+      }),
+      output: fileShape,
+      interval: { default: "1m", floor: "30s" },
+      order: "newest-first",
+      poll: async (ctx, params) => {
+        const clauses = [`'${params.folderId}' in parents`, "trashed = false"];
+        if (params.q !== undefined) clauses.push(params.q);
+        const res = await listPage(ctx, {
+          q: clauses.join(" and "),
+          pageSize: 50,
+          orderBy: "createdTime desc",
+        });
+        return res.files;
+      },
+      dedupeKey: (file: RawFile) => file.id,
+      map: (file: RawFile) => mapFile(file),
+    }),
+  },
+});

package/google-sheets/index.ts

@@ -0,0 +1,361 @@
+// Google Sheets connector — behind the shared `google` Provider (one OAuth app backs
+// gmail + google-calendar + google-sheets). Values ops are 1-based A1 by sheet TITLE;
+// structural ops (addSheet) go through :batchUpdate. No native webhook — newRow polls.
+
+import { z } from "zod";
+import {
+  action,
+  defineConnector,
+  oauth2,
+  trigger,
+  type ClassifyError,
+} from "@devosurf/tesser-sdk/connector";
+import { googleProvider } from "../providers/google.js";
+
+// Google 403 is overloaded: rate-limit 403 is retryable, permission 403 is terminal.
+// Default mapping makes every 4xx terminal, so promote the rate-limit reasons (the
+// reason text rides in the body snippet) back to retry; 429 already retries.
+const googleRetry: ClassifyError = (err) =>
+  err.status === 403 && /rateLimitExceeded|userRateLimitExceeded/.test(err.bodySnippet)
+    ? "retry"
+    : undefined;
+
+// valueInputOption has NO usable default on write methods (the unspecified enum value
+// "must not be used"), so it is always sent. USER_ENTERED parses '=A1+B1' and '5/1'
+// like the UI; RAW stores them as literal text.
+const valueInputOption = z.enum(["USER_ENTERED", "RAW"]).default("USER_ENTERED");
+
+const newRowInput = z.object({
+  spreadsheetId: z.string().min(1),
+  range: z.string().min(1),
+  // Explicit by design: rowIndex suits append-only sheets; keyColumn survives inserts
+  // above the watched range but requires a stable, unique cell value.
+  dedupeMode: z.enum(["rowIndex", "keyColumn"]),
+  keyColumnIndex: z.number().int().min(0).optional(),
+}).superRefine((input, ctx) => {
+  if (input.dedupeMode === "keyColumn" && input.keyColumnIndex === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["keyColumnIndex"],
+      message: "keyColumnIndex is required when dedupeMode is keyColumn",
+    });
+  }
+});
+
+const valueRange = z.object({
+  range: z.string(),
+  values: z.array(z.array(z.string())),
+});
+
+// updatedRange/updatedRows/updatedColumns/updatedCells live INSIDE "updates" on the
+// append response (AppendValuesResponse.updates), not at the top level.
+const updateCounts = z.object({
+  updatedRange: z.string(),
+  updatedRows: z.number(),
+  updatedColumns: z.number(),
+  updatedCells: z.number(),
+});
+
+const sheetMeta = z.object({ sheetId: z.number(), title: z.string() });
+
+type RawValueRange = { range?: string; values?: unknown[][] };
+type RawUpdateCounts = {
+  updatedRange?: string;
+  updatedRows?: number;
+  updatedColumns?: number;
+  updatedCells?: number;
+};
+
+// Range reads omit trailing empty cells (jagged rows) and a fully empty range returns
+// no `values` at all; coerce every cell to a string and tolerate the missing field.
+function rows(raw: RawValueRange): string[][] {
+  return (raw.values ?? []).map((r) => r.map((c) => (c == null ? "" : String(c))));
+}
+
+function counts(raw: RawUpdateCounts): z.infer<typeof updateCounts> {
+  return {
+    updatedRange: raw.updatedRange ?? "",
+    updatedRows: raw.updatedRows ?? 0,
+    updatedColumns: raw.updatedColumns ?? 0,
+    updatedCells: raw.updatedCells ?? 0,
+  };
+}
+
+// {range} path segments carry '!' ':' and spaces — encode them (as gmail/calendar do).
+function valuesPath(spreadsheetId: string, range: string, suffix = ""): string {
+  return `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values/${encodeURIComponent(range)}${suffix}`;
+}
+
+export default defineConnector({
+  id: "google-sheets",
+  describe: "Google Sheets — read and write spreadsheet values and structure",
+  provider: googleProvider,
+  baseUrl: "https://sheets.googleapis.com/v4",
+  auth: oauth2({
+    provider: "google",
+    scopes: [
+      "https://www.googleapis.com/auth/spreadsheets",
+      "https://www.googleapis.com/auth/drive.file",
+    ],
+  }),
+  samples: {
+    "values.get": { range: "Sheet1!A1:B2", values: [["a", "b"], ["c", "d"]] },
+    "values.append": {
+      spreadsheetId: "1abc",
+      tableRange: "Sheet1!A1:B2",
+      updates: {
+        updatedRange: "Sheet1!A3:B3",
+        updatedRows: 1,
+        updatedColumns: 2,
+        updatedCells: 2,
+      },
+    },
+    "values.update": {
+      spreadsheetId: "1abc",
+      updatedRange: "Sheet1!A1:B1",
+      updatedRows: 1,
+      updatedColumns: 2,
+      updatedCells: 2,
+    },
+    "values.clear": { spreadsheetId: "1abc", clearedRange: "Sheet1!A1:B2" },
+    "spreadsheets.get": {
+      spreadsheetId: "1abc",
+      title: "My Sheet",
+      sheets: [{ sheetId: 0, title: "Sheet1" }],
+    },
+    "spreadsheets.create": {
+      spreadsheetId: "1abc",
+      title: "My Sheet",
+      url: "https://docs.google.com/spreadsheets/d/1abc/edit",
+    },
+    "spreadsheets.addSheet": { sheetId: 1, title: "Sheet2", index: 1 },
+    "trigger:newRow": {
+      spreadsheetId: "1abc",
+      range: "Sheet1!A2:Z",
+      rowIndex: 0,
+      values: ["alice", "alice@example.com"],
+    },
+  },
+  actions: {
+    values: {
+      get: action({
+        describe: "Read a range as rows (majorDimension ROWS)",
+        input: z.object({
+          spreadsheetId: z.string().min(1),
+          range: z.string().min(1),
+        }),
+        output: valueRange,
+        safety: "read",
+        classifyError: googleRetry,
+        run: async (ctx, i) => {
+          const res = (await ctx.http.get(valuesPath(i.spreadsheetId, i.range), {
+            query: { majorDimension: "ROWS" },
+          })) as RawValueRange;
+          return { range: res.range ?? i.range, values: rows(res) };
+        },
+      }),
+      append: action({
+        describe: "Append rows after the table touching {range} (non-idempotent)",
+        input: z.object({
+          spreadsheetId: z.string().min(1),
+          range: z.string().min(1),
+          values: z.array(z.array(z.string())).min(1),
+          valueInputOption,
+        }),
+        output: z.object({
+          spreadsheetId: z.string(),
+          tableRange: z.string().optional(),
+          updates: updateCounts,
+        }),
+        // Non-idempotent: a re-run duplicates rows. Stays a plain write (no retrySafe).
+        classifyError: googleRetry,
+        run: async (ctx, i) => {
+          const res = (await ctx.http.post(
+            valuesPath(i.spreadsheetId, i.range, ":append"),
+            { values: i.values },
+            {
+              query: {
+                valueInputOption: i.valueInputOption,
+                insertDataOption: "INSERT_ROWS",
+              },
+            },
+          )) as { spreadsheetId?: string; tableRange?: string; updates?: RawUpdateCounts };
+          return {
+            spreadsheetId: res.spreadsheetId ?? i.spreadsheetId,
+            ...(res.tableRange !== undefined ? { tableRange: res.tableRange } : {}),
+            updates: counts(res.updates ?? {}),
+          };
+        },
+      }),
+      update: action({
+        describe: "Overwrite a fixed range (idempotent-in-effect)",
+        input: z.object({
+          spreadsheetId: z.string().min(1),
+          range: z.string().min(1),
+          values: z.array(z.array(z.string())).min(1),
+          valueInputOption,
+        }),
+        output: z.object({ spreadsheetId: z.string() }).and(updateCounts),
+        // Fixed-range overwrite is idempotent in effect, so retrying is safe.
+        retrySafe: true,
+        classifyError: googleRetry,
+        run: async (ctx, i) => {
+          const res = (await ctx.http.put(
+            valuesPath(i.spreadsheetId, i.range),
+            { values: i.values },
+            { query: { valueInputOption: i.valueInputOption } },
+          )) as { spreadsheetId?: string } & RawUpdateCounts;
+          return { spreadsheetId: res.spreadsheetId ?? i.spreadsheetId, ...counts(res) };
+        },
+      }),
+      clear: action({
+        describe: "Clear values in a range (formatting kept; idempotent)",
+        input: z.object({
+          spreadsheetId: z.string().min(1),
+          range: z.string().min(1),
+        }),
+        output: z.object({ spreadsheetId: z.string(), clearedRange: z.string() }),
+        retrySafe: true,
+        classifyError: googleRetry,
+        run: async (ctx, i) => {
+          // The :clear body MUST be an empty object.
+          const res = (await ctx.http.post(
+            valuesPath(i.spreadsheetId, i.range, ":clear"),
+            {},
+          )) as { spreadsheetId?: string; clearedRange?: string };
+          return {
+            spreadsheetId: res.spreadsheetId ?? i.spreadsheetId,
+            clearedRange: res.clearedRange ?? i.range,
+          };
+        },
+      }),
+    },
+    spreadsheets: {
+      get: action({
+        describe: "Fetch spreadsheet metadata (title + sheet list, no grid)",
+        input: z.object({ spreadsheetId: z.string().min(1) }),
+        output: z.object({
+          spreadsheetId: z.string(),
+          title: z.string(),
+          sheets: z.array(sheetMeta),
+        }),
+        safety: "read",
+        classifyError: googleRetry,
+        run: async (ctx, i) => {
+          // Always send a fields mask; includeGridData would return the entire grid.
+          const res = (await ctx.http.get(
+            `/spreadsheets/${encodeURIComponent(i.spreadsheetId)}`,
+            { query: { fields: "spreadsheetId,properties.title,sheets.properties" } },
+          )) as {
+            spreadsheetId?: string;
+            properties?: { title?: string };
+            sheets?: Array<{ properties?: { sheetId?: number; title?: string } }>;
+          };
+          return {
+            spreadsheetId: res.spreadsheetId ?? i.spreadsheetId,
+            title: res.properties?.title ?? "",
+            sheets: (res.sheets ?? []).map((s) => ({
+              sheetId: s.properties?.sheetId ?? 0,
+              title: s.properties?.title ?? "",
+            })),
+          };
+        },
+      }),
+      create: action({
+        describe: "Create a spreadsheet (lands an app-scoped Drive file; non-idempotent)",
+        input: z.object({ title: z.string().min(1) }),
+        output: z.object({
+          spreadsheetId: z.string(),
+          title: z.string(),
+          url: z.string(),
+        }),
+        classifyError: googleRetry,
+        run: async (ctx, i) => {
+          const res = (await ctx.http.post("/spreadsheets", {
+            properties: { title: i.title },
+          })) as {
+            spreadsheetId?: string;
+            properties?: { title?: string };
+            spreadsheetUrl?: string;
+          };
+          return {
+            spreadsheetId: res.spreadsheetId ?? "",
+            title: res.properties?.title ?? i.title,
+            url: res.spreadsheetUrl ?? "",
+          };
+        },
+      }),
+      addSheet: action({
+        describe: "Add a tab via :batchUpdate addSheet",
+        input: z.object({
+          spreadsheetId: z.string().min(1),
+          title: z.string().min(1),
+        }),
+        output: sheetMeta.extend({ index: z.number() }),
+        classifyError: googleRetry,
+        run: async (ctx, i) => {
+          const res = (await ctx.http.post(
+            `/spreadsheets/${encodeURIComponent(i.spreadsheetId)}:batchUpdate`,
+            { requests: [{ addSheet: { properties: { title: i.title } } }] },
+          )) as {
+            replies?: Array<{
+              addSheet?: { properties?: { sheetId?: number; title?: string; index?: number } };
+            }>;
+          };
+          const props = res.replies?.[0]?.addSheet?.properties ?? {};
+          return {
+            sheetId: props.sheetId ?? 0,
+            title: props.title ?? i.title,
+            index: props.index ?? 0,
+          };
+        },
+      }),
+    },
+  },
+  triggers: {
+    newRow: trigger.poll({
+      describe: "Fires for each new row in a range (poll-only; Sheets has no webhook)",
+      input: newRowInput,
+      output: z.object({
+        spreadsheetId: z.string(),
+        range: z.string(),
+        rowIndex: z.number(),
+        values: z.array(z.string()),
+      }),
+      // One read per poll; respect the 60 reads/min/user ceiling.
+      interval: { default: "1m", floor: "30s" },
+      // Rows read top-to-bottom; runtime fires new ones oldest-first.
+      order: "oldest-first",
+      // poll() carries the explicit dedupe mode onto each row so dedupeKey (item-only)
+      // can read it; map() strips it back to the stable output shape.
+      poll: async (ctx, params) => {
+        const res = (await ctx.http.get(valuesPath(params.spreadsheetId, params.range), {
+          query: { majorDimension: "ROWS" },
+        })) as RawValueRange;
+        return rows(res).map((values, rowIndex) => ({
+          spreadsheetId: params.spreadsheetId,
+          range: params.range,
+          rowIndex,
+          values,
+          dedupeMode: params.dedupeMode,
+          keyColumnIndex: params.keyColumnIndex,
+        }));
+      },
+      // rowIndex mode is append-only but preserves duplicate rows; keyColumn mode is
+      // shift-safe for inserts/deletes above the range when the chosen cell is stable.
+      dedupeKey: (item) => {
+        if (item.dedupeMode === "keyColumn") {
+          const cell = item.values[item.keyColumnIndex ?? -1] ?? "";
+          return `${item.spreadsheetId}:${item.range}:key:${item.keyColumnIndex}:${cell}`;
+        }
+        return `${item.spreadsheetId}:${item.range}:row:${item.rowIndex}`;
+      },
+      map: (item) => ({
+        spreadsheetId: item.spreadsheetId,
+        range: item.range,
+        rowIndex: item.rowIndex,
+        values: item.values,
+      }),
+    }),
+  },
+});

package/http/index.ts

@@ -0,0 +1,76 @@
+// Generic HTTP connector — the escape hatch for services without a typed connector
+// (CONTEXT.md "Secret" spirit: not the default reach). No real credential of its own;
+// pair it with `secrets: { … }` on the automation when a bespoke endpoint needs one.
+
+import { z } from "zod";
+import { action, customAuth, defineConnector } from "@devosurf/tesser-sdk/connector";
+
+const requestInput = z.object({
+  method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]).default("GET"),
+  url: z.string().url(),
+  headers: z.record(z.string(), z.string()).optional(),
+  query: z.record(z.string(), z.string()).optional(),
+  /** JSON-encoded unless `bodyText` is used instead. */
+  body: z.unknown().optional(),
+  bodyText: z.string().optional(),
+});
+
+const response = z.object({
+  status: z.number(),
+  body: z.unknown(),
+  headers: z.record(z.string(), z.string()),
+});
+
+async function perform(
+  http: import("@devosurf/tesser-sdk/connector").ActionCtx["http"],
+  i: z.infer<typeof requestInput>,
+): Promise<z.infer<typeof response>> {
+  const res = (await http.request({
+    method: i.method,
+    path: i.url,
+    raw: true,
+    ...(i.headers !== undefined ? { headers: i.headers } : {}),
+    ...(i.query !== undefined ? { query: i.query } : {}),
+    ...(i.bodyText !== undefined ? { body: i.bodyText } : i.body !== undefined ? { body: i.body } : {}),
+  })) as Response;
+  const text = await res.text();
+  let body: unknown = text;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    // keep text
+  }
+  const headers: Record<string, string> = {};
+  res.headers.forEach((v, k) => {
+    headers[k] = v;
+  });
+  return { status: res.status, body, headers };
+}
+
+export default defineConnector({
+  id: "http",
+  describe: "Plain HTTP requests to any endpoint",
+  // No credential fields: the connection is ready the moment it is created.
+  auth: customAuth({ describe: "No credential — requests go out as-is", sign: () => {} }),
+  samples: {
+    request: { status: 200, body: { ok: true }, headers: { "content-type": "application/json" } },
+    get: { status: 200, body: { ok: true }, headers: { "content-type": "application/json" } },
+  },
+  actions: {
+    request: action({
+      describe: "Perform an HTTP request (any method)",
+      input: requestInput,
+      output: response,
+      // A generic request can be a write; never auto-retry it.
+      retrySafe: false,
+      run: async (ctx, i) => perform(ctx.http, i),
+    }),
+    get: action({
+      describe: "Perform an HTTP GET",
+      input: requestInput.pick({ url: true, headers: true, query: true }),
+      output: response,
+      safety: "read",
+      run: async (ctx, i) => perform(ctx.http, { ...i, method: "GET" }),
+    }),
+  },
+});