Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 21 additions & 5 deletions src/providers/fallback-chain.ts
Original file line number Diff line number Diff line change
@@ -1,25 +1,41 @@
import type { MemoryProvider } from "../types.js";

type ImageProvider = MemoryProvider &
Required<Pick<MemoryProvider, "describeImage">>;

export class FallbackChainProvider implements MemoryProvider {
name: string;
declare readonly describeImage?: MemoryProvider["describeImage"];

constructor(private providers: MemoryProvider[]) {
this.name = `fallback(${providers.map((p) => p.name).join(" -> ")})`;
const imageProviders = providers.filter(
(provider): provider is ImageProvider =>
typeof provider.describeImage === "function",
);
if (imageProviders.length > 0) {
this.describeImage = (imageData, mimeType, prompt) =>
this.tryAll(
(provider) => provider.describeImage(imageData, mimeType, prompt),
imageProviders,
);
}
}

async compress(systemPrompt: string, userPrompt: string): Promise<string> {
return this.tryAll((p) => p.compress(systemPrompt, userPrompt));
return this.tryAll((p) => p.compress(systemPrompt, userPrompt), this.providers);
}

async summarize(systemPrompt: string, userPrompt: string): Promise<string> {
return this.tryAll((p) => p.summarize(systemPrompt, userPrompt));
return this.tryAll((p) => p.summarize(systemPrompt, userPrompt), this.providers);
}

private async tryAll(
fn: (p: MemoryProvider) => Promise<string>,
private async tryAll<T extends MemoryProvider>(
fn: (p: T) => Promise<string>,
providers: T[],
): Promise<string> {
let lastError: Error | null = null;
for (const provider of this.providers) {
for (const provider of providers) {
try {
return await fn(provider);
} catch (err) {
Expand Down
6 changes: 6 additions & 0 deletions src/providers/resilient.ts
Original file line number Diff line number Diff line change
Expand Up @@ -12,9 +12,15 @@ export function isPayloadRejection(err: unknown): boolean {
export class ResilientProvider implements MemoryProvider {
private breaker = new CircuitBreaker();
name: string;
declare readonly describeImage?: MemoryProvider["describeImage"];

constructor(private inner: MemoryProvider) {
this.name = `resilient(${inner.name})`;
const describeImage = inner.describeImage;
if (typeof describeImage === "function") {
this.describeImage = (imageData, mimeType, prompt) =>
this.call(() => describeImage.call(inner, imageData, mimeType, prompt));
}
}

private async call(fn: () => Promise<string>): Promise<string> {
Expand Down
71 changes: 71 additions & 0 deletions test/provider-vision.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,71 @@
import { describe, expect, it, vi } from "vitest";
import { FallbackChainProvider } from "../src/providers/fallback-chain.js";
import { ResilientProvider } from "../src/providers/resilient.js";
import type { MemoryProvider } from "../src/types.js";

function textOnly(name: string): MemoryProvider {
return {
name,
compress: async () => `compressed by ${name}`,
summarize: async () => `summarized by ${name}`,
};
}

function withVision(
name: string,
describeImage: MemoryProvider["describeImage"],
): MemoryProvider {
return { ...textOnly(name), describeImage };
}

describe("provider wrappers keep image description", () => {
it("ResilientProvider forwards describeImage with its arguments", async () => {
const describe = vi.fn(async () => "a red dot");
const provider = new ResilientProvider(withVision("vision", describe));

await expect(provider.describeImage?.("data", "image/png", "prompt")).resolves.toBe(
"a red dot",
);
expect(describe).toHaveBeenCalledWith("data", "image/png", "prompt");
Comment on lines +21 to +29

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔍 Factory-to-caption coverage gap

The ResilientProvider tests construct wrappers directly; no test exercises factory-created vision providers through compression. Existing multimodal tests inject mocks directly. The PR description claims factory-to-persistence coverage that these tests do not provide.

Devin Review


Was this helpful? React with 👍 or 👎 to provide feedback.

});

it("ResilientProvider leaves describeImage absent for a text-only provider", () => {
expect(new ResilientProvider(textOnly("text")).describeImage).toBeUndefined();
});

it("ResilientProvider counts image failures in the shared circuit breaker", async () => {
const provider = new ResilientProvider(
withVision("vision", async () => {
throw new Error("gateway down");
}),
);
for (let i = 0; i < 5; i++) {
await provider.describeImage?.("data", "image/png", "prompt").catch(() => {});
}
await expect(provider.compress("sys", "user")).rejects.toThrow(/circuit/i);
});

it("FallbackChainProvider skips text-only providers and falls through in order", async () => {
const failing = vi.fn(async () => {
throw new Error("first down");
});
const working = vi.fn(async () => "from second");
const chain = new FallbackChainProvider([
textOnly("text"),
withVision("first", failing),
withVision("second", working),
]);

await expect(chain.describeImage?.("data", "image/png", "prompt")).resolves.toBe(
"from second",
);
expect(failing).toHaveBeenCalledOnce();
expect(working).toHaveBeenCalledWith("data", "image/png", "prompt");
});

it("FallbackChainProvider leaves describeImage absent when no provider supports it", () => {
expect(
new FallbackChainProvider([textOnly("a"), textOnly("b")]).describeImage,
).toBeUndefined();
});
});
Loading