Swamp Extension Driver

Create TypeScript execution drivers in extensions/drivers/ that swamp loads at startup.

Quick Reference

Task	Command/Action
Search community	swamp extension search driver --json
Create driver file	Create extensions/drivers/my-driver/mod.ts
Verify registration	swamp model type search --json
Push extension	swamp extension push manifest.yaml --json
Dry-run push	swamp extension push manifest.yaml --dry-run

Quick Start

1. Create the driver file:

// extensions/drivers/my-driver/mod.ts
import { z } from "npm:zod@4";

const ConfigSchema = z.object({
  host: z.string(),
  port: z.number().default(22),
});

export const driver = {
  type: "@myorg/my-driver",
  name: "My Custom Driver",
  description: "Executes model methods on a remote host via SSH",
  configSchema: ConfigSchema,
  createDriver: (config: Record<string, unknown>) => {
    const parsed = ConfigSchema.parse(config);
    return {
      type: "@myorg/my-driver",
      execute: async (request: {
        protocolVersion: number;
        modelType: string;
        modelId: string;
        methodName: string;
        globalArgs: Record<string, unknown>;
        methodArgs: Record<string, unknown>;
        definitionMeta: {
          id: string;
          name: string;
          version: number;
          tags: Record<string, string>;
        };
        bundle?: Uint8Array;
      }, callbacks?: { onLog?: (line: string) => void }) => {
        const start = performance.now();
        const logs: string[] = [];

        try {
          callbacks?.onLog?.(
            `Executing ${request.methodName} on ${parsed.host}:${parsed.port}`,
          );
          logs.push(`Connected to ${parsed.host}`);

          // Your execution logic here
          const output = new TextEncoder().encode(
            JSON.stringify({ result: "ok" }),
          );

          return {
            status: "success" as const,
            outputs: [{
              kind: "pending" as const,
              specName: request.methodName,
              name: request.methodName,
              type: "resource" as const,
              content: output,
            }],
            logs,
            durationMs: performance.now() - start,
          };
        } catch (error) {
          return {
            status: "error" as const,
            error: String(error),
            outputs: [],
            logs,
            durationMs: performance.now() - start,
          };
        }
      },
    };
  },
};