Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import { describe, expect, it } from "@effect/vitest";
import type {
ImageGenerationRequest,
ImageGenerationSettings,
ImageProviderId,
} from "@akeru/contracts";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import { TestClock } from "effect/testing";
import {
CHATGPT_IMAGE_CAPABILITIES,
GROK_IMAGE_CAPABILITIES,
ImageAdapterFailure,
type ImageAdapterRequest,
type ImageProviderAdapter,
} from "./adapters.ts";
import {
IMAGE_REQUEST_TIMEOUT,
type ImageProviderAvailability,
type ImageRouteInput,
imageRoutePlan,
routeImageRequest,
} from "./router.ts";
import { pngBytes } from "./testImages.ts";
const bothEnabled: ImageGenerationSettings = {
chatgptEnabled: true,
grokEnabled: true,
defaultProvider: "chatgpt",
fallbackOrder: ["chatgpt", "grok"],
};
interface FakeAdapter extends ImageProviderAdapter {
readonly calls: ImageAdapterRequest[];
readonly signals: AbortSignal[];
}
function fakeAdapter(
provider: ImageProviderId,
behavior: "ok" | ImageAdapterFailure | "hang" = "ok",
): FakeAdapter {
const calls: ImageAdapterRequest[] = [];
const signals: AbortSignal[] = [];
return {
provider,
capabilities: provider === "chatgpt" ? CHATGPT_IMAGE_CAPABILITIES : GROK_IMAGE_CAPABILITIES,
calls,
signals,
run: (request, signal) => {
calls.push(request);
signals.push(signal);
if (behavior === "ok") {
return Promise.resolve({ images: [pngBytes(16, 16)], model: `${provider}-model` });
}
if (behavior === "hang") return new Promise(() => {});
return Promise.reject(behavior);
},
};
}
const available = (): ImageProviderAvailability => ({ state: "available" });
function routeInput(
overrides: Partial<Omit<ImageRouteInput, "request">> & {
readonly request?: Partial<ImageGenerationRequest>;
} = {},
): ImageRouteInput & { adapters: Record<ImageProviderId, FakeAdapter> } {
const adapters = (overrides.adapters ?? {
chatgpt: fakeAdapter("chatgpt"),
grok: fakeAdapter("grok"),
}) as Record<ImageProviderId, FakeAdapter>;
return {
settings: bothEnabled,
botOverride: null,
availability: available,
inputImages: [],
...overrides,
adapters,
request: { operation: "generate", prompt: "A lighthouse at dusk", ...overrides.request },
};
}
const editImage = [{ mimeType: "image/png", bytes: pngBytes(4, 4) }];
describe("imageRoutePlan", () => {
it("orders bot override, then default, then fallback order", () => {
expect(
imageRoutePlan({ settings: bothEnabled, botOverride: "grok", explicit: undefined }),
).toEqual({ intended: "grok", candidates: ["grok", "chatgpt"] });
expect(
imageRoutePlan({ settings: bothEnabled, botOverride: null, explicit: undefined }),
).toEqual({
intended: "chatgpt",
candidates: ["chatgpt", "grok"],
});
expect(
imageRoutePlan({ settings: bothEnabled, botOverride: "chatgpt", explicit: "grok" }),
).toEqual({ intended: "grok", candidates: ["grok"] });
});
});
describe("routeImageRequest", () => {
it.effect("routes to ChatGPT only when only ChatGPT is enabled", () =>
Effect.gen(function* () {
const input = routeInput({
settings: { ...bothEnabled, grokEnabled: false, defaultProvider: null },
});
const result = yield* routeImageRequest(input);
expect(result.status).toBe("completed");
expect(result.status === "completed" && result.provider).toBe("chatgpt");
expect(input.adapters.grok.calls).toHaveLength(0);
}),
);
it.effect("routes to Grok only when only Grok is enabled", () =>
Effect.gen(function* () {
const input = routeInput({
settings: { ...bothEnabled, chatgptEnabled: false },
request: { aspectRatio: "16:9" },
});
const result = yield* routeImageRequest(input);
expect(result.status === "completed" && result.provider).toBe("grok");
expect(input.adapters.chatgpt.calls).toHaveLength(0);
}),
);
it.effect("uses the bot override over the global default", () =>
Effect.gen(function* () {
const input = routeInput({ botOverride: "grok" });
const result = yield* routeImageRequest(input);
expect(result.status === "completed" && result.provider).toBe("grok");
expect(input.adapters.chatgpt.calls).toHaveLength(0);
}),
);
it.effect("reports disabled when no provider is enabled", () =>
Effect.gen(function* () {
const result = yield* routeImageRequest(
routeInput({ settings: { ...bothEnabled, chatgptEnabled: false, grokEnabled: false } }),
);
expect(result).toMatchObject({ status: "failed", kind: "disabled", attempts: [] });
}),
);
it.effect("skips an unavailable or revoked provider and records why", () =>
Effect.gen(function* () {
const input = routeInput({
availability: (provider) =>
provider === "chatgpt"
? { state: "unavailable", kind: "revoked", message: "Reconnect ChatGPT." }
: { state: "available" },
});
const result = yield* routeImageRequest(input);
expect(result).toMatchObject({
status: "completed",
provider: "grok",
attempts: [
{ provider: "chatgpt", outcome: "revoked" },
{ provider: "grok", outcome: "completed" },
],
});
expect(input.adapters.chatgpt.calls).toHaveLength(0);
}),
);
it.effect("reports the last availability failure when nothing can run", () =>
Effect.gen(function* () {
const result = yield* routeImageRequest(
routeInput({
availability: () => ({
state: "unavailable",
kind: "unavailable",
message: "Not connected.",
}),
}),
);
expect(result).toMatchObject({
status: "failed",
kind: "unavailable",
message: "Not connected.",
});
}),
);
it.effect("preserves an unavailable intended provider when the fallback cannot edit", () =>
Effect.gen(function* () {
const input = routeInput({
inputImages: [...editImage, ...editImage],
request: { operation: "edit", inputImages: ["a", "b"] },
availability: (provider) =>
provider === "chatgpt"
? { state: "unavailable", kind: "revoked", message: "Reconnect ChatGPT." }
: { state: "available" },
});
const result = yield* routeImageRequest(input);
expect(result).toMatchObject({
status: "failed",
kind: "revoked",
message: "Reconnect ChatGPT.",
attempts: [
{ provider: "chatgpt", outcome: "revoked" },
{ provider: "grok", outcome: "unsupported" },
],
});
expect(input.adapters.grok.calls).toHaveLength(0);
}),
);
it.effect("falls back after a provider failure", () =>
Effect.gen(function* () {
const outcomes: Array<[ImageProviderId, boolean]> = [];
const input = routeInput({
adapters: {
chatgpt: fakeAdapter("chatgpt", new ImageAdapterFailure("provider-failed", "boom")),
grok: fakeAdapter("grok"),
},
onAttempt: (provider, outcome) => Effect.sync(() => outcomes.push([provider, outcome.ok])),
});
const result = yield* routeImageRequest(input);
expect(result.status === "completed" && result.provider).toBe("grok");
expect(outcomes).toEqual([
["chatgpt", false],
["grok", true],
]);
}),
);
it.effect("reports the provider failure when the fallback is unavailable", () =>
Effect.gen(function* () {
const result = yield* routeImageRequest(
routeInput({
adapters: {
chatgpt: fakeAdapter("chatgpt", new ImageAdapterFailure("provider-failed", "boom")),
grok: fakeAdapter("grok"),
},
availability: (provider) =>
provider === "grok"
? { state: "unavailable", kind: "unavailable", message: "Grok is not connected." }
: { state: "available" },
}),
);
expect(result).toMatchObject({ status: "failed", kind: "provider-failed", message: "boom" });
}),
);
it.effect("keeps a successful image when a later ChatGPT request fails", () =>
Effect.gen(function* () {
const chatgpt = fakeAdapter("chatgpt");
const run = chatgpt.run;
let calls = 0;
const input = routeInput({
request: { count: 2, provider: "chatgpt" },
adapters: {
chatgpt: {
...chatgpt,
run: (request, signal) => {
calls += 1;
return calls === 2
? Promise.reject(new ImageAdapterFailure("provider-failed", "Second failed."))
: run(request, signal);
},
},
grok: fakeAdapter("grok"),
},
});
const result = yield* routeImageRequest(input);
expect(result).toMatchObject({ status: "failed", kind: "provider-failed" });
expect(result.parts).toHaveLength(1);
expect(calls).toBe(2);
expect(input.adapters.grok.calls).toHaveLength(0);
}),
);
it.effect("asks fallback for only the images ChatGPT did not produce", () =>
Effect.gen(function* () {
const chatgpt = fakeAdapter("chatgpt");
const run = chatgpt.run;
let calls = 0;
const fallbackCounts: number[] = [];
const input = routeInput({
request: { count: 3 },
adapters: {
chatgpt: {
...chatgpt,
run: (request, signal) => {
calls += 1;
if (calls === 2) {
chatgpt.calls.push(request);
return Promise.reject(new ImageAdapterFailure("provider-failed", "Second failed."));
}
return run(request, signal);
},
},
grok: {
...fakeAdapter("grok"),
run: (request) => {
fallbackCounts.push(request.count);
return Promise.resolve({
images: Array.from({ length: request.count }, () => pngBytes(16, 16)),
model: "grok-model",
});
},
},
},
});
const result = yield* routeImageRequest(input);
expect(result.status).toBe("completed");
expect(input.adapters.chatgpt.calls.map((call) => call.count)).toEqual([1, 1]);
expect(fallbackCounts).toEqual([2]);
expect(result.parts[1]?.output.images).toHaveLength(2);
expect(result.parts.map((part) => part.provider)).toEqual(["chatgpt", "grok"]);
}),
);
it.effect("does not fall back after an invalid request", () =>
Effect.gen(function* () {
const input = routeInput({
adapters: {
chatgpt: fakeAdapter("chatgpt", new ImageAdapterFailure("invalid-request", "Refused.")),
grok: fakeAdapter("grok"),
},
});
const result = yield* routeImageRequest(input);
expect(result).toMatchObject({
status: "failed",
kind: "invalid-request",
message: "Refused.",
});
expect(input.adapters.grok.calls).toHaveLength(0);
}),
);
it.effect("never falls back from an explicit provider", () =>
Effect.gen(function* () {
const input = routeInput({
request: { provider: "chatgpt" },
adapters: {
chatgpt: fakeAdapter("chatgpt", new ImageAdapterFailure("provider-failed", "Down.")),
grok: fakeAdapter("grok"),
},
});
const result = yield* routeImageRequest(input);
expect(result).toMatchObject({ status: "failed", kind: "provider-failed" });
expect(input.adapters.grok.calls).toHaveLength(0);
}),
);
it.effect("rejects an edit the intended provider cannot serve", () =>
Effect.gen(function* () {
const input = routeInput({
botOverride: "grok",
inputImages: [...editImage, ...editImage],
request: { operation: "edit", inputImages: ["a", "b"] },
});
const result = yield* routeImageRequest(input);
expect(result).toMatchObject({ status: "failed", kind: "unsupported" });
expect(input.adapters.grok.calls).toHaveLength(0);
expect(input.adapters.chatgpt.calls).toHaveLength(0);
}),
);
it.effect("asks before sending an edit's images to a fallback provider", () =>
Effect.gen(function* () {
const failing = {
chatgpt: fakeAdapter("chatgpt", new ImageAdapterFailure("timeout", "Slow.")),
grok: fakeAdapter("grok"),
};
const withoutConsent = routeInput({
adapters: failing,
inputImages: editImage,
request: { operation: "edit", inputImages: ["a"] },
});
const result = yield* routeImageRequest(withoutConsent);
expect(result).toMatchObject({ status: "needs-consent", provider: "grok" });
expect(failing.grok.calls).toHaveLength(0);
const withConsent = routeInput({
adapters: failing,
inputImages: editImage,
request: { operation: "edit", inputImages: ["a"], allowProvider: "grok" },
});
const retried = yield* routeImageRequest(withConsent);
expect(retried.status === "completed" && retried.provider).toBe("grok");
expect(failing.grok.calls[0]!.inputImages).toHaveLength(1);
// The consented retry does not wait on the provider that already failed.
expect(failing.chatgpt.calls).toHaveLength(1);
expect(retried.attempts).toEqual([{ provider: "grok", outcome: "completed" }]);
}),
);
it.effect("times out a slow provider and falls back", () =>
Effect.gen(function* () {
const input = routeInput({
adapters: { chatgpt: fakeAdapter("chatgpt", "hang"), grok: fakeAdapter("grok") },
});
const fiber = yield* routeImageRequest(input).pipe(Effect.forkScoped);
yield* Effect.yieldNow;
yield* TestClock.adjust(IMAGE_REQUEST_TIMEOUT);
const result = yield* Fiber.join(fiber);
expect(result).toMatchObject({
status: "completed",
provider: "grok",
attempts: [
{ provider: "chatgpt", outcome: "timeout" },
{ provider: "grok", outcome: "completed" },
],
});
expect(input.adapters.chatgpt.signals[0]!.aborted).toBe(true);
}),
);
it.effect("aborts the provider request when the caller cancels", () =>
Effect.gen(function* () {
const input = routeInput({
adapters: { chatgpt: fakeAdapter("chatgpt", "hang"), grok: fakeAdapter("grok") },
});
const fiber = yield* routeImageRequest(input).pipe(Effect.forkScoped);
yield* Effect.yieldNow;
yield* TestClock.adjust(Duration.seconds(5));
expect(input.adapters.chatgpt.calls).toHaveLength(1);
yield* Fiber.interrupt(fiber);
expect(input.adapters.chatgpt.signals[0]!.aborted).toBe(true);
expect(input.adapters.grok.calls).toHaveLength(0);
}),
);
});