@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/tools/builtins/unsplash-search.js

@@ -0,0 +1,74 @@
+import { imageKeywordsFromQuery, resolveUnsplashImage } from "../../image/image-helpers.js";
+export const unsplashSearchManifest = {
+    name: "unsplash.search",
+    description: "Search Unsplash for candidate photos relevant to a query",
+    capability: "read",
+    timeoutMs: 6000,
+    retryPolicy: { maxAttempts: 2, backoffMs: 150 },
+    idempotent: true,
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["query"],
+        properties: {
+            query: { type: "string", description: "Natural-language photo search query" },
+            limit: { type: "integer", description: "Maximum number of candidates to return (1-5)" }
+        }
+    },
+    outputSchema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["items"],
+        properties: {
+            items: {
+                type: "array",
+                items: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["id", "imageUrl", "thumbUrl", "alt", "author", "sourceUrl"],
+                    properties: {
+                        id: { type: "string" },
+                        imageUrl: { type: "string" },
+                        thumbUrl: { type: "string" },
+                        alt: { type: "string" },
+                        author: { type: "string" },
+                        sourceUrl: { type: "string" }
+                    }
+                }
+            }
+        }
+    }
+};
+function mapResultToCandidate(url, alt) {
+    const sanitizedAlt = alt.trim() || "Unsplash image";
+    const id = url.replace(/[^a-zA-Z0-9]/g, "").slice(-18) || `img_${Date.now()}`;
+    const thumbUrl = url.includes("?") ? `${url}&w=480&q=70` : `${url}?w=480&q=70`;
+    const sourceUrl = url.includes("unsplash.com") ? url : `https://unsplash.com/s/photos/${encodeURIComponent(sanitizedAlt)}`;
+    return {
+        id,
+        imageUrl: url,
+        thumbUrl,
+        alt: sanitizedAlt,
+        author: "Unsplash",
+        sourceUrl
+    };
+}
+export const unsplashSearchHandler = async ({ input }) => {
+    const typed = (input ?? {});
+    const query = typeof typed.query === "string" ? typed.query.trim() : "";
+    const limitRaw = typeof typed.limit === "number" ? typed.limit : 3;
+    const limit = Math.min(5, Math.max(1, Math.trunc(limitRaw)));
+    const usedImageUrls = new Set();
+    if (!query)
+        return { items: [] };
+    const items = [];
+    const keywords = imageKeywordsFromQuery(query, 4);
+    for (let idx = 0; idx < limit; idx += 1) {
+        const resolved = await resolveUnsplashImage(query, { variationIndex: idx, usedImageUrls, subjectKeywords: keywords }, undefined);
+        if (!resolved)
+            continue;
+        usedImageUrls.add(resolved.url);
+        items.push(mapResultToCandidate(resolved.url, resolved.alt));
+    }
+    return { items };
+};

package/dist/tools/executor.d.ts

@@ -0,0 +1,23 @@
+import type { ToolCallContext, ToolExecutionEvent, ToolExecutionPolicy, ToolResult } from "./types.ts";
+import { ToolRegistry } from "./registry.ts";
+type Logger = {
+    info: (payload: Record<string, unknown>, message?: string) => void;
+    warn: (payload: Record<string, unknown>, message?: string) => void;
+};
+type ExecuteArgs = {
+    toolName: string;
+    input: unknown;
+    context: ToolCallContext;
+    policy?: Partial<ToolExecutionPolicy>;
+    signal?: AbortSignal;
+};
+export declare class ToolExecutor {
+    private readonly registry;
+    private readonly logger;
+    private readonly onExecution?;
+    private readonly idempotencyCache;
+    constructor(registry: ToolRegistry, logger: Logger, onExecution?: ((event: ToolExecutionEvent) => void) | undefined);
+    execute(args: ExecuteArgs): Promise<ToolResult>;
+    private emit;
+}
+export {};

package/dist/tools/executor.js

@@ -0,0 +1,169 @@
+import { createHash } from "node:crypto";
+import { validateAgainstSchema } from "./schema-validator.js";
+const DEFAULT_POLICY = {
+    autoRunRead: true,
+    requireApprovalForWrite: true
+};
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function timeoutPromise(ms) {
+    return new Promise((_resolve, reject) => {
+        const t = setTimeout(() => {
+            clearTimeout(t);
+            reject(new Error(`Tool timed out after ${ms}ms`));
+        }, ms);
+    });
+}
+function normalizedToolError(code, message, retryable) {
+    return {
+        ok: false,
+        error: { code, message, retryable }
+    };
+}
+function stableHash(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+export class ToolExecutor {
+    registry;
+    logger;
+    onExecution;
+    idempotencyCache = new Map();
+    constructor(registry, logger, onExecution) {
+        this.registry = registry;
+        this.logger = logger;
+        this.onExecution = onExecution;
+    }
+    async execute(args) {
+        const tool = this.registry.getByName(args.toolName);
+        const startedAt = Date.now();
+        const policy = {
+            autoRunRead: args.policy?.autoRunRead ?? DEFAULT_POLICY.autoRunRead,
+            requireApprovalForWrite: args.policy?.requireApprovalForWrite ?? DEFAULT_POLICY.requireApprovalForWrite
+        };
+        if (!tool || tool.manifest.enabled === false) {
+            return {
+                ...normalizedToolError("tool_not_found", `Tool not found: ${args.toolName}`, false),
+                latencyMs: Date.now() - startedAt,
+                attempts: 1
+            };
+        }
+        if (tool.manifest.capability === "write" && policy.requireApprovalForWrite) {
+            return {
+                ...normalizedToolError("tool_requires_approval", `Tool requires approval: ${tool.manifest.name}`, false),
+                latencyMs: Date.now() - startedAt,
+                attempts: 1
+            };
+        }
+        if (tool.manifest.capability === "read" && !policy.autoRunRead) {
+            return {
+                ...normalizedToolError("tool_auto_run_disabled", `Read tool auto-run disabled: ${tool.manifest.name}`, false),
+                latencyMs: Date.now() - startedAt,
+                attempts: 1
+            };
+        }
+        const inputValidation = validateAgainstSchema(args.input, tool.manifest.inputSchema);
+        if (!inputValidation.ok) {
+            return {
+                ...normalizedToolError("invalid_tool_input", inputValidation.message, false),
+                latencyMs: Date.now() - startedAt,
+                attempts: 1
+            };
+        }
+        const idempotencyKey = `${args.context.traceId}:${tool.manifest.name}:${stableHash(args.input)}`;
+        if (tool.manifest.idempotent && this.idempotencyCache.has(idempotencyKey)) {
+            return this.idempotencyCache.get(idempotencyKey);
+        }
+        const maxAttempts = Math.max(1, tool.manifest.retryPolicy.maxAttempts);
+        const backoffMs = Math.max(0, tool.manifest.retryPolicy.backoffMs ?? 0);
+        let attempts = 0;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            attempts = attempt;
+            try {
+                const combinedSignal = args.signal
+                    ? AbortSignal.any([args.signal, AbortSignal.timeout(tool.manifest.timeoutMs)])
+                    : AbortSignal.timeout(tool.manifest.timeoutMs);
+                // Defense-in-depth: race the handler against a hard timeout Promise.
+                // `combinedSignal` is passed to the handler so well-behaved tools can
+                // abort their underlying I/O, but handlers that forget to wire the
+                // signal through (or underlying SDKs that ignore it) would otherwise
+                // hang forever. The race guarantees we always reject after timeoutMs.
+                const output = await Promise.race([
+                    tool.handler({ input: args.input, context: args.context, manifest: tool.manifest, signal: combinedSignal }),
+                    timeoutPromise(tool.manifest.timeoutMs)
+                ]);
+                const outputValidation = validateAgainstSchema(output, tool.manifest.outputSchema);
+                if (!outputValidation.ok) {
+                    const result = {
+                        ...normalizedToolError("invalid_tool_output", outputValidation.message, false),
+                        latencyMs: Date.now() - startedAt,
+                        attempts
+                    };
+                    this.emit(args, result);
+                    return result;
+                }
+                const result = {
+                    ok: true,
+                    data: output,
+                    latencyMs: Date.now() - startedAt,
+                    attempts
+                };
+                if (tool.manifest.idempotent)
+                    this.idempotencyCache.set(idempotencyKey, result);
+                this.emit(args, result);
+                return result;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const retryable = attempt < maxAttempts;
+                if (retryable && backoffMs > 0)
+                    await sleep(backoffMs * attempt);
+                if (!retryable) {
+                    const result = {
+                        ...normalizedToolError("tool_execution_failed", message.slice(0, 240), false),
+                        latencyMs: Date.now() - startedAt,
+                        attempts
+                    };
+                    this.emit(args, result);
+                    return result;
+                }
+            }
+        }
+        const result = {
+            ...normalizedToolError("tool_execution_failed", "Tool execution failed", false),
+            latencyMs: Date.now() - startedAt,
+            attempts
+        };
+        this.emit(args, result);
+        return result;
+    }
+    emit(args, result) {
+        const payload = {
+            event: "tool_execution",
+            tool: args.toolName,
+            ok: result.ok,
+            latencyMs: result.latencyMs,
+            attempts: result.attempts,
+            traceId: args.context.traceId,
+            siteId: args.context.siteId,
+            sessionId: args.context.sessionId,
+            plannerProvider: args.context.plannerProvider,
+            errorCode: result.error?.code
+        };
+        if (result.ok)
+            this.logger.info(payload, "Tool executed");
+        else
+            this.logger.warn(payload, "Tool execution failed");
+        this.onExecution?.({
+            toolName: args.toolName,
+            ok: result.ok,
+            latencyMs: result.latencyMs,
+            attempts: result.attempts,
+            errorCode: result.error?.code,
+            traceId: args.context.traceId,
+            sessionId: args.context.sessionId,
+            siteId: args.context.siteId,
+            plannerProvider: args.context.plannerProvider
+        });
+    }
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.ts";
+export * from "./schema-validator.ts";
+export * from "./registry.ts";
+export * from "./executor.ts";
+export * from "./runtime.ts";

package/dist/tools/index.js

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./schema-validator.js";
+export * from "./registry.js";
+export * from "./executor.js";
+export * from "./runtime.js";

package/dist/tools/registry.d.ts

@@ -0,0 +1,21 @@
+import type { ToolManifest, RegisteredTool, ToolHandler, RemoteToolRegistration } from "./types.ts";
+export declare class ToolRegistry {
+    private readonly tools;
+    registerBuiltin(manifest: ToolManifest, handler: ToolHandler): void;
+    registerRemote(args: RemoteToolRegistration): void;
+    getByName(name: string): RegisteredTool | undefined;
+    listEnabled(): RegisteredTool[];
+    listManifests(): {
+        source: "builtin" | "remote";
+        endpoint: string | undefined;
+        name: string;
+        description: string;
+        inputSchema: import("./types.ts").JsonSchema;
+        outputSchema: import("./types.ts").JsonSchema;
+        capability: import("./types.ts").ToolCapability;
+        timeoutMs: number;
+        retryPolicy: import("./types.ts").ToolRetryPolicy;
+        idempotent: boolean;
+        enabled?: boolean;
+    }[];
+}

package/dist/tools/registry.js

@@ -0,0 +1,75 @@
+import { validateToolManifestShape } from "./schema-validator.js";
+function normalizeToolName(name) {
+    return name.trim().toLowerCase();
+}
+export class ToolRegistry {
+    tools = new Map();
+    registerBuiltin(manifest, handler) {
+        const valid = validateToolManifestShape(manifest);
+        if (!valid.ok)
+            throw new Error(valid.message);
+        const key = normalizeToolName(manifest.name);
+        this.tools.set(key, {
+            manifest: { ...manifest, enabled: manifest.enabled ?? true },
+            handler,
+            source: "builtin"
+        });
+    }
+    registerRemote(args) {
+        const valid = validateToolManifestShape(args.manifest);
+        if (!valid.ok)
+            throw new Error(valid.message);
+        const endpoint = args.endpoint.trim();
+        if (!/^https?:\/\//i.test(endpoint))
+            throw new Error("remote tool endpoint must be http(s)");
+        const key = normalizeToolName(args.manifest.name);
+        const handler = async ({ input, context, signal }) => {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    ...(args.staticHeaders ?? {}),
+                    ...(context.authHeader ? { authorization: context.authHeader } : {})
+                },
+                body: JSON.stringify({
+                    toolName: args.manifest.name,
+                    arguments: input,
+                    context: {
+                        siteId: context.siteId,
+                        sessionId: context.sessionId,
+                        userId: context.userId,
+                        traceId: context.traceId,
+                        plannerProvider: context.plannerProvider
+                    }
+                }),
+                signal,
+            });
+            if (!response.ok) {
+                const body = await response.text().catch(() => "");
+                throw new Error(`Remote tool failed (${response.status}): ${body.slice(0, 200)}`);
+            }
+            const payload = (await response.json());
+            return payload.data;
+        };
+        this.tools.set(key, {
+            manifest: { ...args.manifest, enabled: args.manifest.enabled ?? true },
+            handler,
+            source: "remote",
+            endpoint,
+            staticHeaders: args.staticHeaders
+        });
+    }
+    getByName(name) {
+        return this.tools.get(normalizeToolName(name));
+    }
+    listEnabled() {
+        return Array.from(this.tools.values()).filter((tool) => tool.manifest.enabled !== false);
+    }
+    listManifests() {
+        return this.listEnabled().map((entry) => ({
+            ...entry.manifest,
+            source: entry.source,
+            endpoint: entry.endpoint
+        }));
+    }
+}

package/dist/tools/runtime.d.ts

@@ -0,0 +1,27 @@
+import type { ToolExecutionEvent, ToolExecutionPolicy, ToolCallContext } from "./types.ts";
+import { ToolRegistry } from "./registry.ts";
+import { ToolExecutor } from "./executor.ts";
+type Logger = {
+    info: (payload: Record<string, unknown>, message?: string) => void;
+    warn: (payload: Record<string, unknown>, message?: string) => void;
+    error: (payload: Record<string, unknown>, message?: string) => void;
+};
+export type ToolRuntime = {
+    registry: ToolRegistry;
+    executor: ToolExecutor;
+    defaultPolicy: ToolExecutionPolicy;
+};
+type CreateToolRuntimeArgs = {
+    logger: Logger;
+    onExecution?: (event: ToolExecutionEvent) => void;
+};
+export declare function createToolRuntime(args: CreateToolRuntimeArgs): Promise<ToolRuntime>;
+export declare function loadRemoteToolRegistrations(registry: ToolRegistry, logger: Logger): Promise<void>;
+export declare function executeToolCall(args: {
+    runtime: ToolRuntime;
+    toolName: string;
+    input: unknown;
+    context: ToolCallContext;
+    policy?: Partial<ToolExecutionPolicy>;
+}): Promise<import("./types.ts").ToolResult>;
+export {};

package/dist/tools/runtime.js

@@ -0,0 +1,48 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { ToolRegistry } from "./registry.js";
+import { ToolExecutor } from "./executor.js";
+export async function createToolRuntime(args) {
+    const registry = new ToolRegistry();
+    const defaultPolicy = {
+        autoRunRead: true,
+        requireApprovalForWrite: true
+    };
+    const executor = new ToolExecutor(registry, args.logger, args.onExecution);
+    await loadRemoteToolRegistrations(registry, args.logger);
+    return { registry, executor, defaultPolicy };
+}
+export async function loadRemoteToolRegistrations(registry, logger) {
+    const manifestPath = process.env.ORCHESTRATOR_TOOL_MANIFEST_PATH?.trim();
+    if (!manifestPath)
+        return;
+    if (!existsSync(manifestPath)) {
+        logger.warn({ manifestPath }, "Tool manifest path not found; skipping remote tool registration");
+        return;
+    }
+    try {
+        const raw = await readFile(manifestPath, "utf8");
+        const parsed = JSON.parse(raw);
+        const items = Array.isArray(parsed.tools) ? parsed.tools : [];
+        for (const item of items) {
+            registry.registerRemote({
+                manifest: item.manifest,
+                endpoint: item.endpoint,
+                staticHeaders: item.staticHeaders
+            });
+        }
+        logger.info({ manifestPath, count: items.length }, "Loaded remote tool registrations");
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        logger.error({ err: detail, manifestPath }, "Failed to load remote tool registrations");
+    }
+}
+export async function executeToolCall(args) {
+    return args.runtime.executor.execute({
+        toolName: args.toolName,
+        input: args.input,
+        context: args.context,
+        policy: args.policy
+    });
+}

package/dist/tools/schema-validator.d.ts

@@ -0,0 +1,24 @@
+import type { JsonSchema } from "./types.ts";
+export type SchemaValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function validateAgainstSchema(value: unknown, schema: JsonSchema, path?: string): SchemaValidationResult;
+export declare function validateToolManifestShape(manifest: {
+    name?: unknown;
+    description?: unknown;
+    capability?: unknown;
+    timeoutMs?: unknown;
+    retryPolicy?: unknown;
+    idempotent?: unknown;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+}): {
+    ok: false;
+    message: string;
+} | {
+    ok: true;
+    message?: undefined;
+};

package/dist/tools/schema-validator.js

@@ -0,0 +1,88 @@
+function typeMatches(schemaType, value) {
+    if (schemaType === "string")
+        return typeof value === "string";
+    if (schemaType === "number")
+        return typeof value === "number" && Number.isFinite(value);
+    if (schemaType === "integer")
+        return typeof value === "number" && Number.isInteger(value);
+    if (schemaType === "boolean")
+        return typeof value === "boolean";
+    if (schemaType === "null")
+        return value === null;
+    if (schemaType === "array")
+        return Array.isArray(value);
+    if (schemaType === "object")
+        return value !== null && typeof value === "object" && !Array.isArray(value);
+    return true;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function validateAgainstSchema(value, schema, path = "$") {
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        if (!schema.enum.some((entry) => Object.is(entry, value))) {
+            return { ok: false, message: `${path}: value is not in enum` };
+        }
+    }
+    if (schema.type && !typeMatches(schema.type, value)) {
+        return { ok: false, message: `${path}: expected ${schema.type}` };
+    }
+    if (schema.type === "array") {
+        if (!Array.isArray(value))
+            return { ok: false, message: `${path}: expected array` };
+        if (schema.items) {
+            for (let idx = 0; idx < value.length; idx += 1) {
+                const result = validateAgainstSchema(value[idx], schema.items, `${path}[${idx}]`);
+                if (!result.ok)
+                    return result;
+            }
+        }
+        return { ok: true };
+    }
+    if (schema.type === "object") {
+        if (!isPlainObject(value))
+            return { ok: false, message: `${path}: expected object` };
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        for (const key of required) {
+            if (!(key in value))
+                return { ok: false, message: `${path}.${key}: required` };
+        }
+        const props = schema.properties ?? {};
+        for (const [key, propSchema] of Object.entries(props)) {
+            if (!(key in value))
+                continue;
+            const result = validateAgainstSchema(value[key], propSchema, `${path}.${key}`);
+            if (!result.ok)
+                return result;
+        }
+        if (schema.additionalProperties === false) {
+            for (const key of Object.keys(value)) {
+                if (!(key in props))
+                    return { ok: false, message: `${path}.${key}: additional property is not allowed` };
+            }
+        }
+    }
+    return { ok: true };
+}
+export function validateToolManifestShape(manifest) {
+    if (typeof manifest.name !== "string" || manifest.name.trim().length === 0)
+        return { ok: false, message: "manifest.name is required" };
+    if (typeof manifest.description !== "string" || manifest.description.trim().length === 0)
+        return { ok: false, message: "manifest.description is required" };
+    if (manifest.capability !== "read" && manifest.capability !== "write")
+        return { ok: false, message: "manifest.capability must be read or write" };
+    if (typeof manifest.timeoutMs !== "number" || !Number.isFinite(manifest.timeoutMs) || manifest.timeoutMs < 250)
+        return { ok: false, message: "manifest.timeoutMs must be >= 250" };
+    if (!isPlainObject(manifest.retryPolicy))
+        return { ok: false, message: "manifest.retryPolicy is required" };
+    if (typeof manifest.retryPolicy.maxAttempts !== "number" || !Number.isInteger(manifest.retryPolicy.maxAttempts) || manifest.retryPolicy.maxAttempts < 1 || manifest.retryPolicy.maxAttempts > 5) {
+        return { ok: false, message: "manifest.retryPolicy.maxAttempts must be an integer between 1 and 5" };
+    }
+    if (typeof manifest.idempotent !== "boolean")
+        return { ok: false, message: "manifest.idempotent must be boolean" };
+    if (!isPlainObject(manifest.inputSchema))
+        return { ok: false, message: "manifest.inputSchema is required" };
+    if (!isPlainObject(manifest.outputSchema))
+        return { ok: false, message: "manifest.outputSchema is required" };
+    return { ok: true };
+}

package/dist/tools/types.d.ts

@@ -0,0 +1,86 @@
+export type JsonSchema = {
+    type?: "object" | "array" | "string" | "number" | "integer" | "boolean" | "null";
+    description?: string;
+    enum?: unknown[];
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean;
+    items?: JsonSchema;
+};
+export type ToolCapability = "read" | "write";
+export type ToolRetryPolicy = {
+    maxAttempts: number;
+    backoffMs?: number;
+};
+export type ToolManifest = {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+    capability: ToolCapability;
+    timeoutMs: number;
+    retryPolicy: ToolRetryPolicy;
+    idempotent: boolean;
+    enabled?: boolean;
+};
+export type ToolCallContext = {
+    siteId: string;
+    sessionId: string;
+    userId?: string;
+    traceId: string;
+    plannerProvider: "anthropic" | "openai" | "gemini" | "demo";
+    authHeader?: string;
+    gdriveFolderId?: string;
+    onStatusUpdate?: (message: string) => void;
+    onImageProgress?: (event: {
+        percent: number;
+        stage: string;
+    }) => void;
+};
+export type ToolError = {
+    code: string;
+    message: string;
+    retryable: boolean;
+};
+export type ToolResult = {
+    ok: boolean;
+    data?: unknown;
+    error?: ToolError;
+    latencyMs: number;
+    attempts: number;
+};
+export type ToolExecutionPolicy = {
+    autoRunRead: boolean;
+    requireApprovalForWrite: boolean;
+};
+export type ToolExecutionEvent = {
+    toolName: string;
+    ok: boolean;
+    latencyMs: number;
+    attempts: number;
+    errorCode?: string;
+    traceId: string;
+    sessionId: string;
+    siteId: string;
+    plannerProvider: string;
+    /** True when the tool was deferred (placeholder returned) to avoid blocking text streaming */
+    deferred?: boolean;
+};
+export type ToolHandler = (args: {
+    input: unknown;
+    context: ToolCallContext;
+    manifest: ToolManifest;
+    signal?: AbortSignal;
+}) => Promise<unknown>;
+export type RegisteredTool = {
+    manifest: ToolManifest;
+    handler: ToolHandler;
+    source: "builtin" | "remote";
+    endpoint?: string;
+    staticHeaders?: Record<string, string>;
+};
+export type RemoteToolRegistration = {
+    manifest: ToolManifest;
+    endpoint: string;
+    staticHeaders?: Record<string, string>;
+};

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/variation-images.d.ts

@@ -0,0 +1,19 @@
+export type UnsplashImage = {
+    url: string;
+    alt: string;
+    query: string;
+};
+export type UnsplashResolveOptions = {
+    variationIndex?: number;
+    subjectKeywords?: string[];
+    usedImageUrls?: Set<string>;
+};
+type ResolveUnsplashImage = (query: string, options?: UnsplashResolveOptions) => Promise<UnsplashImage | null>;
+export declare function resolveDistinctUnsplashImage(args: {
+    query: string;
+    variationIndex: number;
+    usedImageUrls: Set<string>;
+    resolveImage: ResolveUnsplashImage;
+    maxAttempts?: number;
+}): Promise<UnsplashImage | null>;
+export {};