okengine 0.6.0 → 0.7.0

package/src/docker/recipes/ollama.ts

@@ -8,14 +8,19 @@
 
 import type { ImageRecipe } from "../types.ts";
 
-/** Start serve, pull configured model, keep serve in foreground. */
+/**
+ * Start serve, pull configured model, keep serve in foreground.
+ *
+ * Shell `$` must be written as `$$` so Compose does not interpolate `pid` /
+ * `i` as project env (same pattern as the redis recipe).
+ */
 const OLLAMA_BOOT = [
   "set -e",
   "/bin/ollama serve &",
-  "pid=$!",
-  'i=0; until /bin/ollama list >/dev/null 2>&1; do i=$((i+1)); [ "$i" -lt 90 ] || exit 1; sleep 1; done',
-  '/bin/ollama pull "${OKE_AI_MODEL:-qwen3.5:9b}"',
-  "wait $pid",
+  "pid=$$!",
+  'i=0; until /bin/ollama list >/dev/null 2>&1; do i=$$((i+1)); [ "$$i" -lt 90 ] || exit 1; sleep 1; done',
+  '/bin/ollama pull "$${OKE_AI_MODEL:-qwen3.5:9b}"',
+  "wait $$pid",
 ].join("; ");
 
 /** Ollama local model server. API on 11434. */

package/src/docker/stack.integration.test.ts

@@ -1,5 +1,7 @@
 /**
  * Integration: generated compose brings up postgres; app URL talks to it.
+ *
+ * Opt-in via `OKE_TEST_DOCKER=1` plus a live Docker daemon. Never an empty pass.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -8,127 +10,141 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { deriveInfrastructure, formatStackEnv, writeDerivedFiles } from "./index.ts";
 
-async function dockerAvailable(): Promise<boolean> {
+function dockerAvailable(): boolean {
   try {
-    const proc = Bun.spawn(["docker", "info"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    return (await proc.exited) === 0;
+    return Bun.spawnSync(["docker", "info"], { stdout: "pipe", stderr: "pipe" }).exitCode === 0;
   } catch {
     return false;
   }
 }
 
-describe("oke dev --docker postgres integration", () => {
-  test("compose brings up postgres and the app talks to it", async () => {
-    if (!(await dockerAvailable())) {
-      console.warn("skipping: docker daemon not available");
-      return;
-    }
-
-    const dir = await mkdtemp(join(tmpdir(), "oke-stack-pg-"));
-    const dockerDir = join(dir, "docker");
-    const project = `oke-pg-${Date.now()}`;
-    try {
-      const derived = deriveInfrastructure({
-        images: { "store.sql": "postgres:18-alpine" },
-        credentials: {
-          "store.sql": {
-            user: "oke",
-            password: "stack-integration-pass",
-            database: "oke",
-          },
-        },
-        app: "stacktest",
-        host: "127.0.0.1",
-        includeApp: false,
-        composeDir: "docker",
-      });
-      await writeDerivedFiles(derived, dockerDir, {
-        writeStackEnv: true,
-      });
+const WANT = process.env.OKE_TEST_DOCKER === "1";
+const DOCKER = WANT && dockerAvailable();
+if (!DOCKER) {
+  console.log(
+    WANT
+      ? "skip: docker postgres stack e2e (docker daemon not available)"
+      : "skip: docker postgres stack e2e (OKE_TEST_DOCKER≠1)",
+  );
+}
+const live = DOCKER ? test : test.skip;
 
-      // Infra-only: network + role compose (no app build).
-      const composeFiles = ["compose.yml", "compose.store.sql.yml"];
-      const up = Bun.spawn(
-        ["docker", "compose", "-p", project, ...composeFiles.flatMap((f) => ["-f", f]), "up", "-d"],
-        {
-          cwd: dockerDir,
-          stdout: "pipe",
-          stderr: "pipe",
-          env: {
-            ...process.env,
-            ...derived.stackEnv,
+describe("oke dev --docker postgres integration", () => {
+  live(
+    "compose brings up postgres and the app talks to it",
+    async () => {
+      const dir = await mkdtemp(join(tmpdir(), "oke-stack-pg-"));
+      const dockerDir = join(dir, "docker");
+      const project = `oke-pg-${Date.now()}`;
+      try {
+        const derived = deriveInfrastructure({
+          images: { "store.sql": "postgres:18-alpine" },
+          credentials: {
+            "store.sql": {
+              user: "oke",
+              password: "stack-integration-pass",
+              database: "oke",
+            },
           },
-        },
-      );
-      const [upOut, upErr, upCode] = await Promise.all([
-        new Response(up.stdout).text(),
-        new Response(up.stderr).text(),
-        up.exited,
-      ]);
-      expect(upCode).toBe(0);
-      if (upCode !== 0) console.error(upOut, upErr);
+          app: "stacktest",
+          host: "127.0.0.1",
+          includeApp: false,
+          composeDir: "docker",
+        });
+        await writeDerivedFiles(derived, dockerDir, {
+          writeStackEnv: true,
+        });
 
-      // Wait for healthy
-      let healthy = false;
-      for (let i = 0; i < 40; i++) {
-        const ps = Bun.spawn(
+        // Infra-only: network + role compose (no app build).
+        const composeFiles = ["compose.yml", "compose.store.sql.yml"];
+        const up = Bun.spawn(
           [
             "docker",
             "compose",
             "-p",
             project,
             ...composeFiles.flatMap((f) => ["-f", f]),
-            "ps",
-            "--format",
-            "json",
+            "up",
+            "-d",
           ],
-          { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
+          {
+            cwd: dockerDir,
+            stdout: "pipe",
+            stderr: "pipe",
+            env: {
+              ...process.env,
+              ...derived.stackEnv,
+            },
+          },
         );
-        const text = await new Response(ps.stdout).text();
-        await ps.exited;
-        if (/healthy/i.test(text)) {
-          healthy = true;
-          break;
+        const [upOut, upErr, upCode] = await Promise.all([
+          new Response(up.stdout).text(),
+          new Response(up.stderr).text(),
+          up.exited,
+        ]);
+        expect(upCode).toBe(0);
+        if (upCode !== 0) console.error(upOut, upErr);
+
+        // Wait for healthy
+        let healthy = false;
+        for (let i = 0; i < 40; i++) {
+          const ps = Bun.spawn(
+            [
+              "docker",
+              "compose",
+              "-p",
+              project,
+              ...composeFiles.flatMap((f) => ["-f", f]),
+              "ps",
+              "--format",
+              "json",
+            ],
+            { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
+          );
+          const text = await new Response(ps.stdout).text();
+          await ps.exited;
+          if (/healthy/i.test(text)) {
+            healthy = true;
+            break;
+          }
+          await Bun.sleep(500);
         }
-        await Bun.sleep(500);
-      }
-      expect(healthy).toBe(true);
+        expect(healthy).toBe(true);
 
-      const url = derived.stackEnv.DATABASE_URL!;
-      // App talks to postgres via recipe URL (Bun.SQL) — kernel never sees env-var names.
-      const sql = new Bun.SQL(url);
-      try {
-        const rows = (await sql`select 1::int as n`) as Array<{ n: number }>;
-        expect(rows[0]?.n).toBe(1);
+        const url = derived.stackEnv.DATABASE_URL!;
+        // App talks to postgres via recipe URL (Bun.SQL) — kernel never sees env-var names.
+        const sql = new Bun.SQL(url);
+        try {
+          const rows = (await sql`select 1::int as n`) as Array<{ n: number }>;
+          expect(rows[0]?.n).toBe(1);
+        } finally {
+          await sql.close();
+        }
+
+        // Prove credentials live in docker/.env.docker, not YAML.
+        const yml = await Bun.file(join(dockerDir, "compose.store.sql.yml")).text();
+        expect(yml).not.toContain("stack-integration-pass");
+        expect(formatStackEnv(derived.stackEnv)).toContain("stack-integration-pass");
+        expect(await Bun.file(join(dockerDir, ".env.docker")).exists()).toBe(true);
       } finally {
-        await sql.close();
+        await Bun.spawn(
+          [
+            "docker",
+            "compose",
+            "-p",
+            project,
+            "-f",
+            "compose.yml",
+            "-f",
+            "compose.store.sql.yml",
+            "down",
+            "-v",
+          ],
+          { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
+        ).exited.catch(() => {});
+        await rm(dir, { recursive: true, force: true }).catch(() => {});
       }
-
-      // Prove credentials live in docker/.env.docker, not YAML.
-      const yml = await Bun.file(join(dockerDir, "compose.store.sql.yml")).text();
-      expect(yml).not.toContain("stack-integration-pass");
-      expect(formatStackEnv(derived.stackEnv)).toContain("stack-integration-pass");
-      expect(await Bun.file(join(dockerDir, ".env.docker")).exists()).toBe(true);
-    } finally {
-      await Bun.spawn(
-        [
-          "docker",
-          "compose",
-          "-p",
-          project,
-          "-f",
-          "compose.yml",
-          "-f",
-          "compose.store.sql.yml",
-          "down",
-          "-v",
-        ],
-        { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
-      ).exited.catch(() => {});
-      await rm(dir, { recursive: true, force: true }).catch(() => {});
-    }
-  }, 120_000);
+    },
+    120_000,
+  );
 });

package/src/drivers/ai-ollama-tools.integration.test.ts

@@ -1,7 +1,8 @@
 /**
  * Live Ollama tool-calling through fx.ask → fx.call (capability + ledger).
  *
- * Same skip-visible convention as ai-ollama.integration.test.ts.
+ * Opt-in via `OKE_TEST_OLLAMA_URL` (reachable Ollama). A local daemon on
+ * :11434 is not enough — set the URL explicitly. Never an empty pass.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -11,7 +12,6 @@ import { createGateRuntime, gate } from "../elements/gate.ts";
 import { createFxContext } from "../kernel/fx.ts";
 import { OLLAMA_DEFAULT_MODEL, openOllama } from "./ai-ollama.ts";
 
-const DEFAULT_LOCAL = "http://127.0.0.1:11434";
 const ENV_URL = process.env.OKE_TEST_OLLAMA_URL?.trim();
 
 async function probeOllama(url: string): Promise<boolean> {
@@ -23,12 +23,14 @@ async function probeOllama(url: string): Promise<boolean> {
   }
 }
 
-const localUp = ENV_URL ? await probeOllama(ENV_URL) : await probeOllama(DEFAULT_LOCAL);
-const canLive = Boolean(ENV_URL) || localUp;
+const reachable = ENV_URL ? await probeOllama(ENV_URL) : false;
+const canLive = Boolean(ENV_URL) && reachable;
 
 if (!canLive) {
   console.log(
-    "skip: live ollama tool-calling e2e (OKE_TEST_OLLAMA_URL not set; no Ollama on :11434)",
+    ENV_URL
+      ? `skip: live ollama tool-calling e2e (unreachable at ${ENV_URL})`
+      : "skip: live ollama tool-calling e2e (OKE_TEST_OLLAMA_URL not set)",
   );
 }
 const live = canLive ? test : test.skip;
@@ -37,7 +39,7 @@ describe("ollama live — tool-calling via fx.call", () => {
   live(
     "gated ask → real tool call → capability ledger portal entry",
     async () => {
-      const url = ENV_URL || DEFAULT_LOCAL;
+      const url = ENV_URL!;
       const model = process.env.OKE_AI_MODEL?.trim() || OLLAMA_DEFAULT_MODEL;
 
       const kv = await memoryKvDriver.open({ name: "ollama-tools-rate" });

package/src/drivers/ai-ollama.integration.test.ts

@@ -3,11 +3,11 @@
  *
  * Opt-in (never auto-pull a multi-GB model in ordinary `bun test`):
  * 1. `OKE_TEST_OLLAMA_URL` — point at any reachable Ollama
- * 2. Ollama already listening on `http://127.0.0.1:11434`
- * 3. `OKE_TEST_OLLAMA_DOCKER=1` — start `ollama/ollama` via the recipe and pull
+ * 2. `OKE_TEST_OLLAMA_DOCKER=1` — start `ollama/ollama` via the recipe and pull
  *    `qwen3.5:9b` (slow first run)
  *
  * Without one of those, the suite skips with a visible reason (never an empty pass).
+ * A local daemon on :11434 is not enough — set `OKE_TEST_OLLAMA_URL` explicitly.
  */
 
 import { afterAll, describe, expect, test } from "bun:test";
@@ -20,7 +20,6 @@ import { bindAi } from "../kernel/boot-bind/ai.ts";
 import { OLLAMA_DEFAULT_MODEL, openOllama } from "./ai-ollama.ts";
 
 const OLLAMA_IMAGE = "ollama/ollama:latest";
-const DEFAULT_LOCAL = "http://127.0.0.1:11434";
 const ENV_URL = process.env.OKE_TEST_OLLAMA_URL?.trim();
 const WANT_DOCKER = process.env.OKE_TEST_OLLAMA_DOCKER === "1";
 
@@ -32,23 +31,12 @@ function dockerAvailable(): boolean {
   }
 }
 
-async function probeOllama(url: string): Promise<boolean> {
-  try {
-    const res = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(1_500) });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
 const DOCKER = dockerAvailable();
-const localUp = ENV_URL ? false : await probeOllama(DEFAULT_LOCAL);
-const canLive = Boolean(ENV_URL) || localUp || (WANT_DOCKER && DOCKER);
+const canLive = Boolean(ENV_URL) || (WANT_DOCKER && DOCKER);
 
 if (!canLive) {
   const reasons: string[] = [];
   if (!ENV_URL) reasons.push("OKE_TEST_OLLAMA_URL not set");
-  if (!localUp) reasons.push("no Ollama on :11434");
   if (!WANT_DOCKER) reasons.push("OKE_TEST_OLLAMA_DOCKER≠1");
   else if (!DOCKER) reasons.push("docker daemon not available");
   console.log(`skip: live ollama e2e (${reasons.join("; ")})`);
@@ -94,10 +82,6 @@ async function resolveLiveUrl(): Promise<{ url: string; model: string }> {
     return { url: ENV_URL, model: process.env.OKE_AI_MODEL?.trim() || OLLAMA_DEFAULT_MODEL };
   }
 
-  if (localUp) {
-    return { url: DEFAULT_LOCAL, model: process.env.OKE_AI_MODEL?.trim() || OLLAMA_DEFAULT_MODEL };
-  }
-
   const dir = await mkdtemp(join(tmpdir(), "oke-ollama-"));
   const dockerDir = join(dir, "docker");
   const project = `oke-ollama-${Date.now()}`;

package/src/drivers/ai-ollama.ts

@@ -7,14 +7,17 @@
  * configured but unreachable throws {@link OllamaUnavailableError} — never a
  * silent mock fallback.
  *
- * Native API: `POST /api/chat` (not the OpenAI-compat shim). Default base URL
- * `http://127.0.0.1:11434`. Supports `complete`, `stream` (NDJSON), and tools.
+ * Native API: `POST /api/chat` and `POST /api/embeddings` (not the OpenAI-compat
+ * shim). Default base URL `http://127.0.0.1:11434`. Supports `complete`,
+ * `stream` (NDJSON), `embed`, and tools.
  */
 
 import type {
   AiCompleteOptions,
   AiCompleteResult,
   AiDriver,
+  AiEmbedOptions,
+  AiEmbedResult,
   AiModelClient,
   AiOpenOptions,
   AiStreamChunk,
@@ -158,6 +161,41 @@ export async function openOllama(options: AiOpenOptions = {}): Promise<AiModelCl
       }
       yield* readOllamaNdjson(res.body, opts.signal);
     },
+    async embed(opts: AiEmbedOptions): Promise<AiEmbedResult> {
+      const resolvedModel = resolveOllamaModel(options, opts.model);
+      const inputs = Array.isArray(opts.input) ? opts.input : [opts.input];
+      const vectors: number[][] = [];
+
+      for (const prompt of inputs) {
+        let res: Response;
+        try {
+          res = await fetchFn(`${baseUrl}/api/embeddings`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: resolvedModel, prompt }),
+          });
+        } catch (err) {
+          throw new OllamaUnavailableError(
+            `ollama: unreachable at ${baseUrl} — ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+        const raw = (await res.json().catch(() => ({}))) as OllamaEmbedResponse;
+        if (!res.ok) {
+          const msg = raw.error ?? `ollama embed HTTP ${res.status}`;
+          throw new OllamaUnavailableError(`ollama: ${msg}`);
+        }
+        if (!Array.isArray(raw.embedding)) {
+          throw new OllamaUnavailableError("ollama: embed response missing embedding");
+        }
+        vectors.push(raw.embedding);
+      }
+
+      return {
+        vectors,
+        model: resolvedModel,
+        driverId: "ollama",
+      };
+    },
   };
 }
 
@@ -325,3 +363,8 @@ interface OllamaChatResponse {
   readonly eval_count?: number;
   readonly error?: string;
 }
+
+interface OllamaEmbedResponse {
+  readonly embedding?: readonly number[];
+  readonly error?: string;
+}

package/src/drivers/ai-providers.test.ts

@@ -318,6 +318,37 @@ describe("ollama driver", () => {
     expect(calls[0]!.body.options).toEqual({ temperature: 0, num_predict: 16 });
   });
 
+  test("embed via injectable fetch — native /api/embeddings", async () => {
+    const paths: string[] = [];
+    const fetchFn: typeof fetch = Object.assign(
+      async (input: string | URL | Request) => {
+        const url = String(input);
+        paths.push(url);
+        if (url.endsWith("/api/tags")) {
+          return new Response(JSON.stringify({ models: [] }), { status: 200 });
+        }
+        if (url.endsWith("/api/embeddings")) {
+          return new Response(JSON.stringify({ embedding: [0.1, 0.2, 0.3] }), {
+            status: 200,
+          });
+        }
+        return new Response(JSON.stringify({ error: "unexpected" }), { status: 500 });
+      },
+      { preconnect: () => {} },
+    ) as typeof fetch;
+
+    const client = await openOllama({
+      model: "nomic-embed-text",
+      baseUrl: "http://ollama.test:11434",
+      fetch: fetchFn,
+    });
+    const emb = await client.embed!({ input: ["a", "b"] });
+    expect(emb.driverId).toBe("ollama");
+    expect(emb.vectors).toHaveLength(2);
+    expect(emb.vectors[0]).toEqual([0.1, 0.2, 0.3]);
+    expect(paths.filter((p) => p.endsWith("/api/embeddings"))).toHaveLength(2);
+  });
+
   test("unreachable server throws OllamaUnavailableError (no silent fallback)", async () => {
     const fetchFn: typeof fetch = Object.assign(
       async () => {

package/src/drivers/channel-fcm.ts

@@ -1,7 +1,9 @@
 /**
- * `fcm` channel driver — Firebase Cloud Messaging HTTP v1 (protocol-shaped).
+ * `fcm` channel driver — Firebase Cloud Messaging HTTP v1 via sently.
  */
 
+import { FcmTransport } from "sently/transports/fcm";
+import { mapSentlySendError, mapSentlySendResult } from "./channel-sently-map.ts";
 import type {
   ChannelDriver,
   ChannelMessage,
@@ -13,70 +15,64 @@ import type {
 /**
  * Open an FCM push driver.
  *
- * @param options - `token` (OAuth access token) + `from` (project id)
+ * Prefer service-account credentials (`clientEmail` + `privateKey` + `from`/
+ * `projectId`). For tests, pass `token` as a pre-fetched access token via
+ * `getAccessToken` (still requires `from` / project id).
+ *
+ * @param options - Project id + service account or injectable token
  */
 export function openFcmChannel(options: ChannelOpenOptions = {}): ChannelDriver {
+  const projectId = options.projectId ?? options.from;
+  if (!projectId) {
+    throw new Error("fcm channel: projectId (or from) is required");
+  }
+
+  const clientEmail = options.clientEmail ?? options.user;
+  const privateKey = options.privateKey ?? options.pass;
   const accessToken = options.token ?? options.apiKey;
-  const projectId = options.from;
-  const fetchFn = options.fetch ?? globalThis.fetch;
-  const base = options.url ?? "https://fcm.googleapis.com";
+
+  if (!accessToken && !(clientEmail && privateKey)) {
+    throw new Error(
+      "fcm channel: clientEmail+privateKey (service account) or token (access token) required",
+    );
+  }
+  if ((clientEmail && !privateKey) || (!clientEmail && privateKey)) {
+    throw new Error("fcm channel: clientEmail and privateKey must be provided together");
+  }
+
+  // Token-only mode (tests / pre-fetched OAuth): sently still requires placeholder
+  // service-account fields; getAccessToken skips JWT exchange.
+  const transport = new FcmTransport({
+    projectId,
+    clientEmail: clientEmail ?? "oke-fcm@local",
+    privateKey:
+      privateKey ??
+      "-----BEGIN PRIVATE KEY-----\nMIIEowIBAAKCAQEA0Z3VS5JJcds3xfn/ygWyF6PZGFw=\n-----END PRIVATE KEY-----\n",
+    ...(accessToken ? { getAccessToken: async () => accessToken } : {}),
+  });
 
   const channel: ChannelTransport = {
     provider: "fcm",
     mediums: ["push"],
     async send(message: ChannelMessage): Promise<ChannelSendResult> {
-      if (!accessToken || !projectId) {
-        throw new Error("fcm: token and from (project id) are required");
-      }
-      const res = await fetchFn(`${base}/v1/projects/${projectId}/messages:send`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          message: {
-            token: message.to,
-            notification: {
-              title: message.subject ?? message.template ?? "notification",
-              body: message.text ?? "",
-            },
-            data: Object.fromEntries(
-              Object.entries(message.data ?? {}).map(([k, v]) => [k, String(v)]),
-            ),
-          },
-        }),
-      });
-      const body = (await res.json().catch(() => ({}))) as {
-        name?: string;
-        error?: { message?: string };
-      };
-      const id = body.name ?? crypto.randomUUID();
-      if (!res.ok) {
-        return {
-          ok: false,
-          messageId: id,
-          driverId: "fcm",
-          attempts: [
-            {
-              driverId: "fcm",
-              ok: false,
-              error: body.error?.message ?? `HTTP ${res.status}`,
-              at: Date.now(),
-            },
-          ],
-        };
+      try {
+        const title = message.subject ?? message.template ?? "notification";
+        const body = message.text ?? "";
+        const result = await transport.send({
+          token: message.to,
+          title,
+          body,
+          ...(message.data ? { data: { ...message.data } } : {}),
+        });
+        return mapSentlySendResult("fcm", result);
+      } catch (err) {
+        return mapSentlySendError("fcm", err);
       }
-      return {
-        ok: true,
-        messageId: id,
-        driverId: "fcm",
-        attempts: [{ driverId: "fcm", ok: true, at: Date.now(), messageId: id }],
-      };
     },
+    verify: () => transport.verify(),
   };
 
-  return { id: "fcm", channel };
+  return { id: "fcm", channel, pushTransport: transport };
 }
 
 /** FCM driver factory. */

package/src/drivers/channel-msegat.ts

@@ -0,0 +1,61 @@
+/**
+ * `msegat` channel driver — SMS via sently's Msegat transport.
+ */
+
+import { MsegatTransport } from "sently/transports/msegat";
+import { mapSentlySendError, mapSentlySendResult } from "./channel-sently-map.ts";
+import type {
+  ChannelDriver,
+  ChannelMessage,
+  ChannelOpenOptions,
+  ChannelSendResult,
+  ChannelTransport,
+} from "./channel-types.ts";
+
+/**
+ * Open a Msegat SMS driver.
+ *
+ * @param options - `userName`/`user` + `apiKey` + `sender`/`from`
+ */
+export function openMsegatChannel(options: ChannelOpenOptions = {}): ChannelDriver {
+  const userName = options.userName ?? options.user;
+  const apiKey = options.apiKey;
+  const sender = options.sender ?? options.from;
+  if (!userName) {
+    throw new Error("msegat channel: userName (or user) is required");
+  }
+  if (!apiKey) {
+    throw new Error("msegat channel: apiKey is required");
+  }
+  if (!sender) {
+    throw new Error("msegat channel: sender (or from) is required");
+  }
+
+  const transport = new MsegatTransport({ userName, apiKey, sender });
+
+  const channel: ChannelTransport = {
+    provider: "msegat",
+    mediums: ["sms"],
+    async send(message: ChannelMessage): Promise<ChannelSendResult> {
+      try {
+        const result = await transport.send({
+          to: message.to,
+          body: message.text ?? String(message.data?.code ?? ""),
+          ...(message.from ? { from: message.from } : {}),
+        });
+        return mapSentlySendResult("msegat", result);
+      } catch (err) {
+        return mapSentlySendError("msegat", err);
+      }
+    },
+    verify: () => transport.verify(),
+  };
+
+  return { id: "msegat", channel, smsTransport: transport };
+}
+
+/** Msegat driver factory. */
+export const msegatChannelDriver = {
+  id: "msegat" as const,
+  open: openMsegatChannel,
+};