webfox 0.0.0-test.0 → 4.0.1

package/dist/providers/contract.d.ts

@@ -0,0 +1,88 @@
+import type { Capability as Tool, ProviderId, SearchResult } from "../domain.js";
+import type { IndexedContentsResponse } from "../contents.js";
+export interface SearchResponse {
+    provider: ProviderId;
+    results: SearchResult[];
+}
+export interface ToolOutput {
+    provider: ProviderId;
+    text: string;
+    itemCount?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ResearchJob {
+    id: string;
+}
+export interface ResearchPollResult {
+    status: "in_progress" | "completed" | "failed" | "cancelled";
+    statusText?: string;
+    output?: ToolOutput;
+    error?: string;
+}
+export interface ProviderContext {
+    cwd: string;
+    env?: Record<string, string | undefined>;
+    signal?: AbortSignal;
+    onProgress?: (message: string) => void;
+    idempotencyKey?: string;
+    retryPolicy?: {
+        retries: number;
+        delayMs: number;
+    };
+}
+export interface SearchRequest {
+    capability: "search";
+    query: string;
+    maxResults: number;
+    options?: Record<string, unknown>;
+}
+export interface ContentsRequest {
+    capability: "contents";
+    urls: string[];
+    options?: Record<string, unknown>;
+}
+export interface AnswerRequest {
+    capability: "answer";
+    query: string;
+    options?: Record<string, unknown>;
+}
+export interface ResearchRequest {
+    capability: "research";
+    input: string;
+    options?: Record<string, unknown>;
+}
+export interface ProviderRequestMap {
+    search: SearchRequest;
+    contents: ContentsRequest;
+    answer: AnswerRequest;
+    research: ResearchRequest;
+}
+export type ProviderRequest<TTool extends Tool = Tool> = ProviderRequestMap[TTool];
+export interface ProviderResultMap {
+    search: SearchResponse;
+    contents: IndexedContentsResponse;
+    answer: ToolOutput;
+    research: ToolOutput;
+}
+export type ProviderResult<TTool extends Tool = Tool> = ProviderResultMap[TTool];
+export interface Provider {
+    credentials?: Record<string, string>;
+}
+export type { Capability as Tool, ProviderId, SearchResult, } from "../domain.js";
+export interface ProviderConfigMap {
+    brave: import("./brave/types.js").Brave;
+    cloudflare: import("./cloudflare/types.js").Cloudflare;
+    custom: import("./custom/types.js").Custom;
+    exa: import("./exa/types.js").Exa;
+    firecrawl: import("./firecrawl/types.js").Firecrawl;
+    gemini: import("./gemini/types.js").Gemini;
+    linkup: import("./linkup/types.js").Linkup;
+    ollama: import("./ollama/types.js").Ollama;
+    openai: import("./openai/types.js").OpenAI;
+    parallel: import("./parallel/types.js").Parallel;
+    perplexity: import("./perplexity/types.js").Perplexity;
+    serper: import("./serper/types.js").Serper;
+    tavily: import("./tavily/types.js").Tavily;
+    valyu: import("./valyu/types.js").Valyu;
+}
+export type ProviderConfig<T extends ProviderId = ProviderId> = ProviderConfigMap[T];

package/dist/providers/custom/adapter.d.ts

@@ -0,0 +1,9 @@
+import type { IndexedContentsResponse } from "../../contents.js";
+import type { Custom } from "./types.js";
+import type { ProviderContext, ProviderRequest, SearchResponse, ToolOutput } from "../contract.js";
+export declare const adapter: {
+    search(request: ProviderRequest<"search">, config: Custom, context: ProviderContext): Promise<SearchResponse>;
+    contents(request: ProviderRequest<"contents">, config: Custom, context: ProviderContext): Promise<IndexedContentsResponse>;
+    answer(request: ProviderRequest<"answer">, config: Custom, context: ProviderContext): Promise<ToolOutput>;
+    research(request: ProviderRequest<"research">, config: Custom, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/custom/definition.d.ts

@@ -0,0 +1 @@
+export declare const customProvider: import("../definition.js").ProviderDefinitionFor<"custom">;

package/dist/providers/custom/types.d.ts

@@ -0,0 +1,9 @@
+import type { Capability } from "../../domain.js";
+export interface CustomCommandConfig {
+    argv: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface Custom {
+    commands?: Partial<Record<Capability, CustomCommandConfig>>;
+}

package/dist/providers/definition.d.ts

@@ -0,0 +1,32 @@
+import type { Capability, ProviderId } from "../domain.js";
+import type { CredentialSource, ProviderConfiguration } from "../configuration/types.js";
+import type { ProviderConfigMap, ProviderContext, ProviderRequest, ProviderResult } from "./contract.js";
+import type { ProviderCredentialMetadata } from "./metadata.js";
+export interface CapabilityDefinition {
+    options?: Record<string, unknown>;
+    limits?: {
+        maxResults?: number;
+    };
+    promptGuidelines?: readonly string[];
+    /** Whether the entire operation may be repeated after a transient failure. */
+    retrySafe: boolean;
+}
+export type ProviderAdapter<I extends ProviderId> = {
+    [C in Capability]?: (request: ProviderRequest<C>, config: ProviderConfigMap[I], context: ProviderContext) => Promise<ProviderResult<C>>;
+};
+export interface ProviderDefinitionFor<I extends ProviderId> {
+    id: I;
+    label: string;
+    docsUrl: string;
+    local: boolean;
+    credentials: readonly ProviderCredentialMetadata[];
+    fields: readonly (keyof ProviderConfiguration)[];
+    credentialDefaults: Record<string, CredentialSource>;
+    defaults: Partial<Record<Capability, Record<string, unknown>>>;
+    capabilities: Partial<Record<Capability, CapabilityDefinition>>;
+    load(): Promise<ProviderAdapter<I>>;
+}
+export type ProviderDefinition = {
+    [I in ProviderId]: ProviderDefinitionFor<I>;
+}[ProviderId];
+export declare function defineProvider<I extends ProviderId>(definition: ProviderDefinitionFor<I>): ProviderDefinitionFor<I>;

package/dist/providers/exa/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderContext, SearchResponse, ToolOutput } from "../contract.js";
+import type { Exa } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Exa, context: ProviderContext): Promise<SearchResponse>;
+    contents(input: import("../contract.js").ProviderRequest<"contents">, config: Exa, context: ProviderContext): Promise<import("../../contents.js").IndexedContentsResponse>;
+    answer(input: import("../contract.js").ProviderRequest<"answer">, config: Exa, context: ProviderContext): Promise<ToolOutput>;
+    research(input: import("../contract.js").ProviderRequest<"research">, config: Exa, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/exa/definition.d.ts

@@ -0,0 +1 @@
+export declare const exaProvider: import("../definition.js").ProviderDefinitionFor<"exa">;

package/dist/providers/exa/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Exa extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/firecrawl/adapter.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderContext, SearchResponse, ToolOutput } from "../contract.js";
+import type { Firecrawl } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Firecrawl, context: ProviderContext): Promise<SearchResponse>;
+    contents(input: import("../contract.js").ProviderRequest<"contents">, config: Firecrawl, context: ProviderContext): Promise<import("../../contents.js").IndexedContentsResponse>;
+    answer(input: import("../contract.js").ProviderRequest<"answer">, config: Firecrawl, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/firecrawl/definition.d.ts

@@ -0,0 +1 @@
+export declare const firecrawlProvider: import("../definition.js").ProviderDefinitionFor<"firecrawl">;

package/dist/providers/firecrawl/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Firecrawl extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/gemini/adapter.d.ts

@@ -0,0 +1,14 @@
+import { GoogleGenAI } from "@google/genai";
+import type { ProviderContext, ResearchJob, ResearchPollResult, ToolOutput } from "../contract.js";
+import type { Gemini } from "./types.js";
+export declare const geminiImplementation: {
+    answer(query: string, config: Gemini, context: ProviderContext, options?: Record<string, unknown>): Promise<ToolOutput>;
+    research(input: string, config: Gemini, context: ProviderContext, options?: Record<string, unknown>): Promise<ToolOutput>;
+    startResearch(input: string, config: Gemini, context: ProviderContext, options?: Record<string, unknown>): Promise<ResearchJob>;
+    pollResearch(id: string, config: Gemini, context: ProviderContext, _options?: Record<string, unknown>): Promise<ResearchPollResult>;
+    createClient(config: Gemini): GoogleGenAI;
+};
+export declare const adapter: {
+    answer(input: import("../contract.js").ProviderRequest<"answer">, config: Gemini, context: ProviderContext): Promise<ToolOutput>;
+    research(input: import("../contract.js").ProviderRequest<"research">, config: Gemini, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/gemini/definition.d.ts

@@ -0,0 +1 @@
+export declare const geminiProvider: import("../definition.js").ProviderDefinitionFor<"gemini">;

package/dist/providers/gemini/types.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "../contract.js";
+export interface Gemini extends Provider {
+}

package/dist/providers/linkup/adapter.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderContext, SearchResponse, ToolOutput } from "../contract.js";
+import type { Linkup } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Linkup, context: ProviderContext): Promise<SearchResponse>;
+    contents(input: import("../contract.js").ProviderRequest<"contents">, config: Linkup, context: ProviderContext): Promise<import("../../contents.js").IndexedContentsResponse>;
+    research(input: import("../contract.js").ProviderRequest<"research">, config: Linkup, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/linkup/definition.d.ts

@@ -0,0 +1 @@
+export declare const linkupProvider: import("../definition.js").ProviderDefinitionFor<"linkup">;

package/dist/providers/linkup/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Linkup extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/metadata.d.ts

@@ -0,0 +1,15 @@
+import type { Capability, ProviderId } from "../domain.js";
+export interface ProviderCredentialMetadata {
+    name: string;
+    environmentVariable: string;
+    capabilities?: readonly Capability[];
+    optional?: boolean;
+}
+export interface ProviderMetadata {
+    id: ProviderId;
+    label: string;
+    docsUrl: string;
+    capabilities: readonly Capability[];
+    credentials: readonly ProviderCredentialMetadata[];
+    local: boolean;
+}

package/dist/providers/ollama/adapter.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderContext, SearchResponse } from "../contract.js";
+import type { Ollama } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Ollama, context: ProviderContext): Promise<SearchResponse>;
+    contents(input: import("../contract.js").ProviderRequest<"contents">, config: Ollama, context: ProviderContext): Promise<import("../../contents.js").IndexedContentsResponse>;
+};

package/dist/providers/ollama/definition.d.ts

@@ -0,0 +1 @@
+export declare const ollamaProvider: import("../definition.js").ProviderDefinitionFor<"ollama">;

package/dist/providers/ollama/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Ollama extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/openai/adapter.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderContext, SearchResponse, ToolOutput } from "../contract.js";
+import type { OpenAI as OpenAIConfig } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: OpenAIConfig, context: ProviderContext): Promise<SearchResponse>;
+    answer(input: import("../contract.js").ProviderRequest<"answer">, config: OpenAIConfig, context: ProviderContext): Promise<ToolOutput>;
+    research(input: import("../contract.js").ProviderRequest<"research">, config: OpenAIConfig, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/openai/definition.d.ts

@@ -0,0 +1 @@
+export declare const openaiProvider: import("../definition.js").ProviderDefinitionFor<"openai">;

package/dist/providers/openai/types.d.ts

@@ -0,0 +1,28 @@
+import type { Provider } from "../contract.js";
+export interface OpenAIWebSearchToolOptions {
+    externalWebAccess?: boolean;
+    searchContextSize?: "low" | "medium" | "high";
+    allowedDomains?: string[];
+    userLocation?: {
+        city?: string;
+        country?: string;
+        region?: string;
+        timezone?: string;
+    };
+}
+export interface OpenAISearchOptions extends OpenAIWebSearchToolOptions {
+    model?: string;
+    instructions?: string;
+}
+export interface OpenAIAnswerOptions extends OpenAIWebSearchToolOptions {
+    model?: string;
+    instructions?: string;
+}
+export interface OpenAIResearchOptions extends OpenAIWebSearchToolOptions {
+    model?: string;
+    instructions?: string;
+    max_tool_calls?: number;
+}
+export interface OpenAI extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/parallel/adapter.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderContext, SearchResponse } from "../contract.js";
+import type { Parallel } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Parallel, context: ProviderContext): Promise<SearchResponse>;
+    contents(input: import("../contract.js").ProviderRequest<"contents">, config: Parallel, context: ProviderContext): Promise<import("../../contents.js").IndexedContentsResponse>;
+};

package/dist/providers/parallel/definition.d.ts

@@ -0,0 +1 @@
+export declare const parallelProvider: import("../definition.js").ProviderDefinitionFor<"parallel">;

package/dist/providers/parallel/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Parallel extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/perplexity/adapter.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderContext, SearchResponse, ToolOutput } from "../contract.js";
+import type { Perplexity } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Perplexity, context: ProviderContext): Promise<SearchResponse>;
+    answer(input: import("../contract.js").ProviderRequest<"answer">, config: Perplexity, context: ProviderContext): Promise<ToolOutput>;
+    research(input: import("../contract.js").ProviderRequest<"research">, config: Perplexity, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/perplexity/definition.d.ts

@@ -0,0 +1 @@
+export declare const perplexityProvider: import("../definition.js").ProviderDefinitionFor<"perplexity">;

package/dist/providers/perplexity/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Perplexity extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/registry.d.ts

@@ -0,0 +1,16 @@
+export declare const providers: {
+    readonly brave: import("./definition.js").ProviderDefinitionFor<"brave">;
+    readonly cloudflare: import("./definition.js").ProviderDefinitionFor<"cloudflare">;
+    readonly custom: import("./definition.js").ProviderDefinitionFor<"custom">;
+    readonly exa: import("./definition.js").ProviderDefinitionFor<"exa">;
+    readonly firecrawl: import("./definition.js").ProviderDefinitionFor<"firecrawl">;
+    readonly gemini: import("./definition.js").ProviderDefinitionFor<"gemini">;
+    readonly linkup: import("./definition.js").ProviderDefinitionFor<"linkup">;
+    readonly ollama: import("./definition.js").ProviderDefinitionFor<"ollama">;
+    readonly openai: import("./definition.js").ProviderDefinitionFor<"openai">;
+    readonly parallel: import("./definition.js").ProviderDefinitionFor<"parallel">;
+    readonly perplexity: import("./definition.js").ProviderDefinitionFor<"perplexity">;
+    readonly serper: import("./definition.js").ProviderDefinitionFor<"serper">;
+    readonly tavily: import("./definition.js").ProviderDefinitionFor<"tavily">;
+    readonly valyu: import("./definition.js").ProviderDefinitionFor<"valyu">;
+};

package/dist/providers/serper/adapter.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderContext, SearchResponse } from "../contract.js";
+import type { Serper } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Serper, context: ProviderContext): Promise<SearchResponse>;
+};

package/dist/providers/serper/definition.d.ts

@@ -0,0 +1 @@
+export declare const serperProvider: import("../definition.js").ProviderDefinitionFor<"serper">;

package/dist/providers/serper/types.d.ts

@@ -0,0 +1,21 @@
+import type { Provider } from "../contract.js";
+export declare const SERPER_SEARCH_MODE_VALUES: {
+    readonly search: "search";
+    readonly images: "images";
+    readonly videos: "videos";
+    readonly places: "places";
+    readonly maps: "maps";
+    readonly reviews: "reviews";
+    readonly news: "news";
+    readonly shopping: "shopping";
+    readonly productReviews: "product-reviews";
+    readonly lens: "lens";
+    readonly scholar: "scholar";
+    readonly patents: "patents";
+    readonly autocomplete: "autocomplete";
+    readonly webpage: "webpage";
+};
+export type SerperSearchMode = (typeof SERPER_SEARCH_MODE_VALUES)[keyof typeof SERPER_SEARCH_MODE_VALUES];
+export interface Serper extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/shared.d.ts

@@ -0,0 +1,4 @@
+export declare function trimSnippet(input: string | undefined, maxLength?: number): string;
+export declare function normalizeContentText(input: string | undefined): string;
+export declare function asJsonObject(value: Record<string, unknown> | undefined): Record<string, unknown>;
+export declare function formatJson(value: unknown): string;

package/dist/providers/tavily/adapter.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderContext, SearchResponse } from "../contract.js";
+import type { Tavily } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Tavily, context: ProviderContext): Promise<SearchResponse>;
+    contents(input: import("../contract.js").ProviderRequest<"contents">, config: Tavily, context: ProviderContext): Promise<import("../../contents.js").IndexedContentsResponse>;
+};

package/dist/providers/tavily/definition.d.ts

@@ -0,0 +1 @@
+export declare const tavilyProvider: import("../definition.js").ProviderDefinitionFor<"tavily">;

package/dist/providers/tavily/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Tavily extends Provider {
+    baseUrl?: string;
+}

package/dist/providers/valyu/adapter.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderContext, SearchResponse, ToolOutput } from "../contract.js";
+import type { Valyu } from "./types.js";
+export declare const adapter: {
+    search(input: import("../contract.js").ProviderRequest<"search">, config: Valyu, context: ProviderContext): Promise<SearchResponse>;
+    contents(input: import("../contract.js").ProviderRequest<"contents">, config: Valyu, context: ProviderContext): Promise<import("../../contents.js").IndexedContentsResponse>;
+    answer(input: import("../contract.js").ProviderRequest<"answer">, config: Valyu, context: ProviderContext): Promise<ToolOutput>;
+    research(input: import("../contract.js").ProviderRequest<"research">, config: Valyu, context: ProviderContext): Promise<ToolOutput>;
+};

package/dist/providers/valyu/definition.d.ts

@@ -0,0 +1 @@
+export declare const valyuProvider: import("../definition.js").ProviderDefinitionFor<"valyu">;

package/dist/providers/valyu/types.d.ts

@@ -0,0 +1,4 @@
+import type { Provider } from "../contract.js";
+export interface Valyu extends Provider {
+    baseUrl?: string;
+}

package/dist/render.d.ts

@@ -0,0 +1,5 @@
+import type { WebDocument } from "./domain.js";
+/** Presentation is deliberately outside the application/runtime. */
+export declare function renderTextDocument(document: WebDocument, { includeErrors }?: {
+    includeErrors?: boolean;
+}): string;

package/dist/runtime/credentials.d.ts

@@ -0,0 +1,15 @@
+import type { Capability, ProviderId } from "../domain.js";
+import type { ProviderConfiguration } from "../configuration/types.js";
+import type { ProviderDefinition } from "../providers/definition.js";
+import type { ProviderConfigMap } from "../providers/contract.js";
+import { OutwardBoundary } from "./outward.js";
+/** Client-scoped environment and cache. Inspection never uses this resolver. */
+export declare class CredentialResolver {
+    private readonly cwd;
+    private readonly env;
+    private readonly cache;
+    constructor(cwd: string, env: Record<string, string | undefined>);
+    prepare(definition: ProviderDefinition, stored: ProviderConfiguration | undefined, capability: Capability, signal: AbortSignal, outward: OutwardBoundary): Promise<ProviderConfigMap[ProviderId]>;
+    private resolveMap;
+    private resolve;
+}

package/dist/runtime/duration.d.ts

@@ -0,0 +1,2 @@
+/** Compact elapsed time for human-facing progress and completion messages. */
+export declare function formatDuration(milliseconds: number): string;

package/dist/runtime/execute.d.ts

@@ -0,0 +1,20 @@
+import type { Capability, CapabilityDocument, CapabilityValues, RequestOptions } from "../domain.js";
+import type { ExecutionConfig, ProviderConfiguration } from "../configuration/types.js";
+import type { ProviderDefinition } from "../providers/definition.js";
+export interface ExecutionPlan<C extends Capability> {
+    capability: C;
+    definition: ProviderDefinition;
+    stored?: ProviderConfiguration;
+    inputs: string[];
+    options: Record<string, unknown>;
+    maxResults?: number;
+    policy: ExecutionConfig;
+}
+export declare class ExecutionRuntime {
+    private readonly cwd;
+    private readonly env;
+    private readonly credentials;
+    constructor(cwd: string, env: Record<string, string | undefined>);
+    execute<C extends Capability>(plan: ExecutionPlan<C>, request: RequestOptions): Promise<CapabilityDocument<CapabilityValues[C], C>>;
+    private run;
+}

package/dist/runtime/lifecycle.d.ts

@@ -0,0 +1,8 @@
+export declare function deadline(timeoutMs: number, parent?: AbortSignal): {
+    signal: AbortSignal;
+    dispose(): void;
+};
+export declare function formatDuration(ms: number): string;
+export declare function withSignal<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+export declare function orderedMap<T, R>(items: T[], concurrency: number, work: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/runtime/outward.d.ts

@@ -0,0 +1,11 @@
+import { WebfoxError } from "../errors.js";
+import type { SerializedError } from "../domain.js";
+/** The only boundary through which internal provider data reaches a caller. */
+export declare class OutwardBoundary {
+    private readonly secrets;
+    addSecret(secret: string): void;
+    text(value: string): string;
+    value<T>(value: T): T;
+    error(error: unknown): SerializedError;
+    exception(error: unknown): WebfoxError;
+}

package/dist/runtime/polling.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderContext, ProviderId, ResearchJob, ResearchPollResult, ToolOutput } from "../providers/contract.js";
+export { sleep } from "./lifecycle.js";
+/** Shared provider polling mechanics. The runtime supplies the overall signal.
+ * Job creation is performed exactly once; only transient polling is repeated.
+ */
+export declare function executeAsyncResearch({ providerLabel, providerId, context, pollIntervalMs, start, poll, }: {
+    providerLabel: string;
+    providerId: ProviderId;
+    context: ProviderContext;
+    pollIntervalMs?: number;
+    start: (context: ProviderContext) => Promise<ResearchJob>;
+    poll: (id: string, context: ProviderContext) => Promise<ResearchPollResult>;
+}): Promise<ToolOutput>;

package/dist/runtime/process.d.ts

@@ -0,0 +1,4 @@
+import type { ChildProcess } from "node:child_process";
+/** Call only for children spawned with detached: true on POSIX. */
+export declare function killProcessGroup(child: ChildProcess, signal: NodeJS.Signals): void;
+export declare function cancelProcessGroup(child: ChildProcess): void;