@noodleseed/one 0.168.0 → 0.170.0

package/node_modules/@noodle-borg/managed-capabilities/dist/contracts.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+export declare const capabilityNameSchema: z.ZodString;
+export declare const webPolicySchema: z.ZodObject<{
+    maxUrls: z.ZodOptional<z.ZodNumber>;
+    maxCalls: z.ZodOptional<z.ZodNumber>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxTextBytes: z.ZodOptional<z.ZodNumber>;
+    domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type WebPolicy = z.infer<typeof webPolicySchema>;
+export declare const webCapabilityBaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    class: z.ZodLiteral<"web.extract.v1">;
+    title: z.ZodString;
+    description: z.ZodString;
+    provider: z.ZodObject<{
+        kind: z.ZodLiteral<"noodle-managed">;
+    }, z.core.$strict>;
+    policy: z.ZodOptional<z.ZodObject<{
+        maxUrls: z.ZodOptional<z.ZodNumber>;
+        maxCalls: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxTextBytes: z.ZodOptional<z.ZodNumber>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export interface CapabilityAuthorization {
+    readonly discovery?: 'authorized' | 'public' | undefined;
+    readonly requiredScopes?: readonly string[] | undefined;
+    readonly allowedRoles?: readonly string[] | undefined;
+}
+export type WebCapability = z.infer<typeof webCapabilityBaseSchema> & {
+    readonly authorization?: CapabilityAuthorization | undefined;
+};
+export declare const webExtractRequestSchema: z.ZodObject<{
+    urls: z.ZodArray<z.ZodString>;
+    domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type WebExtractRequest = z.infer<typeof webExtractRequestSchema>;
+export declare const webExtractResultSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    items: z.ZodArray<z.ZodObject<{
+        requestIndex: z.ZodNumber;
+        sourceRef: z.ZodString;
+        content: z.ZodObject<{
+            format: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>;
+        links: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        retrievedAt: z.ZodISODateTime;
+        publishedAt: z.ZodOptional<z.ZodISODateTime>;
+        observedAt: z.ZodOptional<z.ZodISODateTime>;
+        expiresAt: z.ZodOptional<z.ZodISODateTime>;
+        attribution: z.ZodOptional<z.ZodString>;
+        rights: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        requestIndex: z.ZodNumber;
+        code: z.ZodEnum<{
+            capability_unavailable: "capability_unavailable";
+            capability_binding_invalid: "capability_binding_invalid";
+            capability_requirement_unsupported: "capability_requirement_unsupported";
+            capability_policy_denied: "capability_policy_denied";
+            capability_budget_exhausted: "capability_budget_exhausted";
+            capability_source_rejected: "capability_source_rejected";
+            capability_provider_failed: "capability_provider_failed";
+            capability_result_invalid: "capability_result_invalid";
+            capability_cancelled: "capability_cancelled";
+            content_truncated: "content_truncated";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WebExtractResult = z.infer<typeof webExtractResultSchema>;
+export declare const WEB_CONNECTOR_ID = "noodle_web";
+export declare const WEB_CONNECTOR_VERSION = "1.0.0";
+export declare const webOperationInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    request: z.ZodObject<{
+        urls: z.ZodArray<z.ZodString>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const WEB_OPERATION_SIGNATURE: {
+    type: "read";
+    input: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+        name: z.ZodString;
+        request: z.ZodObject<{
+            urls: z.ZodArray<z.ZodString>;
+            domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    output: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+        status: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+        }>;
+        items: z.ZodArray<z.ZodObject<{
+            requestIndex: z.ZodNumber;
+            sourceRef: z.ZodString;
+            content: z.ZodObject<{
+                format: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>;
+            links: z.ZodArray<z.ZodObject<{
+                url: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        sources: z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            url: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            retrievedAt: z.ZodISODateTime;
+            publishedAt: z.ZodOptional<z.ZodISODateTime>;
+            observedAt: z.ZodOptional<z.ZodISODateTime>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+            attribution: z.ZodOptional<z.ZodString>;
+            rights: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        warnings: z.ZodArray<z.ZodObject<{
+            requestIndex: z.ZodNumber;
+            code: z.ZodEnum<{
+                capability_unavailable: "capability_unavailable";
+                capability_binding_invalid: "capability_binding_invalid";
+                capability_requirement_unsupported: "capability_requirement_unsupported";
+                capability_policy_denied: "capability_policy_denied";
+                capability_budget_exhausted: "capability_budget_exhausted";
+                capability_source_rejected: "capability_source_rejected";
+                capability_provider_failed: "capability_provider_failed";
+                capability_result_invalid: "capability_result_invalid";
+                capability_cancelled: "capability_cancelled";
+                content_truncated: "content_truncated";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+};
+export declare const WEB_CATALOG_CONNECTOR: {
+    id: string;
+    version: string;
+    kind: "builtin";
+    operations: {
+        extract: {
+            type: "read";
+            input: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+                name: z.ZodString;
+                request: z.ZodObject<{
+                    urls: z.ZodArray<z.ZodString>;
+                    domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            output: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+                status: z.ZodEnum<{
+                    complete: "complete";
+                    partial: "partial";
+                }>;
+                items: z.ZodArray<z.ZodObject<{
+                    requestIndex: z.ZodNumber;
+                    sourceRef: z.ZodString;
+                    content: z.ZodObject<{
+                        format: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strict>;
+                    links: z.ZodArray<z.ZodObject<{
+                        url: z.ZodString;
+                        label: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
+                sources: z.ZodArray<z.ZodObject<{
+                    ref: z.ZodString;
+                    url: z.ZodString;
+                    title: z.ZodOptional<z.ZodString>;
+                    retrievedAt: z.ZodISODateTime;
+                    publishedAt: z.ZodOptional<z.ZodISODateTime>;
+                    observedAt: z.ZodOptional<z.ZodISODateTime>;
+                    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+                    attribution: z.ZodOptional<z.ZodString>;
+                    rights: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                warnings: z.ZodArray<z.ZodObject<{
+                    requestIndex: z.ZodNumber;
+                    code: z.ZodEnum<{
+                        capability_unavailable: "capability_unavailable";
+                        capability_binding_invalid: "capability_binding_invalid";
+                        capability_requirement_unsupported: "capability_requirement_unsupported";
+                        capability_policy_denied: "capability_policy_denied";
+                        capability_budget_exhausted: "capability_budget_exhausted";
+                        capability_source_rejected: "capability_source_rejected";
+                        capability_provider_failed: "capability_provider_failed";
+                        capability_result_invalid: "capability_result_invalid";
+                        capability_cancelled: "capability_cancelled";
+                        content_truncated: "content_truncated";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        };
+    };
+};
+//# sourceMappingURL=contracts.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/contracts.js

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { CAPABILITY_ERROR_CODES } from './errors.js';
+import { WEB_EXTRACT_LIMITS as limits } from './limits.js';
+const domainSchema = z
+    .string()
+    .max(253)
+    .regex(/^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z][a-z0-9-]*$/);
+export const capabilityNameSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-z][a-z0-9_]*$/);
+export const webPolicySchema = z
+    .object({
+    maxUrls: z.number().int().min(1).max(limits.maxUrls).optional(),
+    maxCalls: z.number().int().min(1).max(limits.maxCalls).optional(),
+    timeoutMs: z.number().int().min(100).max(limits.timeoutMs).optional(),
+    maxTextBytes: z.number().int().min(256).max(limits.maxTextBytes).optional(),
+    domains: z.array(domainSchema).min(1).max(32).optional(),
+})
+    .strict();
+export const webCapabilityBaseSchema = z
+    .object({
+    name: capabilityNameSchema,
+    class: z.literal('web.extract.v1'),
+    title: z.string().trim().min(1).max(120),
+    description: z.string().trim().min(1).max(1000),
+    provider: z.object({ kind: z.literal('noodle-managed') }).strict(),
+    policy: webPolicySchema.optional(),
+})
+    .strict();
+export const webExtractRequestSchema = z
+    .object({
+    urls: z.array(z.string().min(1).max(limits.maxUrlCharacters)).min(1).max(limits.maxUrls),
+    domains: z.array(domainSchema).min(1).max(32).optional(),
+})
+    .strict();
+const sourceSchema = z
+    .object({
+    ref: z.string().min(1).max(80),
+    url: z.string().max(limits.maxUrlCharacters).url(),
+    title: z.string().max(512).optional(),
+    retrievedAt: z.iso.datetime(),
+    publishedAt: z.iso.datetime().optional(),
+    observedAt: z.iso.datetime().optional(),
+    expiresAt: z.iso.datetime().optional(),
+    attribution: z.string().max(512).optional(),
+    rights: z.string().max(512).optional(),
+})
+    .strict();
+export const webExtractResultSchema = z
+    .object({
+    status: z.enum(['complete', 'partial']),
+    items: z
+        .array(z
+        .object({
+        requestIndex: z
+            .number()
+            .int()
+            .min(0)
+            .max(limits.maxUrls - 1),
+        sourceRef: z.string().min(1).max(80),
+        content: z
+            .object({
+            format: z.literal('text'),
+            text: z.string().min(1).max(limits.maxTextBytes),
+        })
+            .strict(),
+        links: z
+            .array(z
+            .object({
+            url: z.string().max(limits.maxUrlCharacters).url(),
+            label: z.string().max(200).optional(),
+        })
+            .strict())
+            .max(limits.maxLinks),
+        truncated: z.boolean(),
+    })
+        .strict())
+        .min(1)
+        .max(limits.maxUrls),
+    sources: z.array(sourceSchema).min(1).max(limits.maxUrls),
+    warnings: z
+        .array(z
+        .object({
+        requestIndex: z
+            .number()
+            .int()
+            .min(0)
+            .max(limits.maxUrls - 1),
+        code: z.enum([...CAPABILITY_ERROR_CODES, 'content_truncated']),
+    })
+        .strict())
+        .max(limits.maxUrls * 2),
+})
+    .strict();
+export const WEB_CONNECTOR_ID = 'noodle_web';
+export const WEB_CONNECTOR_VERSION = '1.0.0';
+export const webOperationInputSchema = z
+    .object({ name: capabilityNameSchema, request: webExtractRequestSchema })
+    .strict();
+export const WEB_OPERATION_SIGNATURE = {
+    type: 'read',
+    input: z.toJSONSchema(webOperationInputSchema),
+    output: z.toJSONSchema(webExtractResultSchema),
+};
+export const WEB_CATALOG_CONNECTOR = {
+    id: WEB_CONNECTOR_ID,
+    version: WEB_CONNECTOR_VERSION,
+    kind: 'builtin',
+    operations: { extract: WEB_OPERATION_SIGNATURE },
+};
+//# sourceMappingURL=contracts.js.map

package/node_modules/@noodle-borg/managed-capabilities/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export declare const CAPABILITY_ERROR_CODES: readonly ["capability_unavailable", "capability_binding_invalid", "capability_requirement_unsupported", "capability_policy_denied", "capability_budget_exhausted", "capability_source_rejected", "capability_provider_failed", "capability_result_invalid", "capability_cancelled"];
+export type CapabilityErrorCode = (typeof CAPABILITY_ERROR_CODES)[number];
+/** Messages are fixed safe codes: never retain a URL, provider payload or a nested cause. */
+export declare class CapabilityError extends Error {
+    readonly code: CapabilityErrorCode;
+    constructor(code: CapabilityErrorCode);
+}
+//# sourceMappingURL=errors.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/errors.js

@@ -0,0 +1,21 @@
+export const CAPABILITY_ERROR_CODES = [
+    'capability_unavailable',
+    'capability_binding_invalid',
+    'capability_requirement_unsupported',
+    'capability_policy_denied',
+    'capability_budget_exhausted',
+    'capability_source_rejected',
+    'capability_provider_failed',
+    'capability_result_invalid',
+    'capability_cancelled',
+];
+/** Messages are fixed safe codes: never retain a URL, provider payload or a nested cause. */
+export class CapabilityError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'CapabilityError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/node_modules/@noodle-borg/managed-capabilities/dist/executor.d.ts

@@ -0,0 +1,26 @@
+import type { CapabilityBudget } from './budget.js';
+import { type WebCapability, type WebExtractResult, type WebPolicy } from './contracts.js';
+export interface PublicPageReaderPort {
+    read(request: {
+        readonly url: string;
+        readonly domains?: readonly string[];
+        readonly signal: AbortSignal;
+        readonly beforeRequest: () => void;
+        readonly maxBytes: number;
+    }): Promise<unknown>;
+}
+export interface WebExtractDeps {
+    readonly reader: PublicPageReaderPort;
+    readonly budget: CapabilityBudget;
+    readonly enabled: boolean;
+    /** Computed from verified caller claims and the underlying declaration, never from tool arguments. */
+    readonly authorized: boolean;
+    readonly operatorPolicy: WebPolicy;
+    readonly signal?: AbortSignal;
+    /** Durable, attributable admission. A refusal or outage must not dispatch the reader. */
+    readonly admit: () => Promise<boolean>;
+}
+export declare function effectiveWebPolicy(developer?: WebPolicy, operator?: WebPolicy): WebPolicy;
+/** One governed path for generated MCP tools, assistant calls and composed operations. */
+export declare function executeWebExtract(declaration: WebCapability, input: unknown, deps: WebExtractDeps): Promise<WebExtractResult>;
+//# sourceMappingURL=executor.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/executor.js

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+import { webExtractRequestSchema, webExtractResultSchema, webPolicySchema, } from './contracts.js';
+import { CapabilityError } from './errors.js';
+import { WEB_EXTRACT_LIMITS as limits } from './limits.js';
+import { publicPageUrl } from './urls.js';
+const pageSchema = z
+    .object({
+    url: z.string().max(limits.maxUrlCharacters),
+    title: z.string().max(512),
+    text: z.string().min(1).max(limits.maxPageBytes),
+    retrievedAt: z.iso.datetime(),
+    links: z
+        .array(z
+        .object({
+        url: z.string().max(limits.maxUrlCharacters),
+        label: z.string().max(200).optional(),
+    })
+        .strict())
+        .max(limits.maxLinks),
+})
+    .strict();
+export function effectiveWebPolicy(developer = {}, operator = {}) {
+    const a = webPolicySchema.parse(developer);
+    const b = webPolicySchema.parse(operator);
+    const domains = intersectDomains(a.domains, b.domains);
+    return {
+        maxUrls: Math.min(a.maxUrls ?? limits.maxUrls, b.maxUrls ?? limits.maxUrls),
+        maxCalls: Math.min(a.maxCalls ?? limits.maxCalls, b.maxCalls ?? limits.maxCalls),
+        timeoutMs: Math.min(a.timeoutMs ?? limits.timeoutMs, b.timeoutMs ?? limits.timeoutMs),
+        maxTextBytes: Math.min(a.maxTextBytes ?? limits.maxTextBytes, b.maxTextBytes ?? limits.maxTextBytes),
+        ...(domains === undefined ? {} : { domains }),
+    };
+}
+function intersectDomains(a, b) {
+    return a === undefined
+        ? b === undefined
+            ? undefined
+            : [...b]
+        : b === undefined
+            ? [...a]
+            : a.filter((host) => b.includes(host));
+}
+/** One governed path for generated MCP tools, assistant calls and composed operations. */
+export async function executeWebExtract(declaration, input, deps) {
+    if (!deps.enabled)
+        throw new CapabilityError('capability_unavailable');
+    if (!deps.authorized)
+        throw new CapabilityError('capability_policy_denied');
+    if (deps.signal?.aborted)
+        throw new CapabilityError('capability_cancelled');
+    const request = webExtractRequestSchema.safeParse(input);
+    if (!request.success)
+        throw new CapabilityError('capability_source_rejected');
+    const policy = effectiveWebPolicy(declaration.policy, deps.operatorPolicy);
+    const domains = intersectDomains(policy.domains, request.data.domains);
+    if (request.data.urls.length > (policy.maxUrls ?? limits.maxUrls))
+        throw new CapabilityError('capability_policy_denied');
+    const urls = request.data.urls.map((url) => publicPageUrl(url, domains).href);
+    if (new Set(urls).size !== urls.length)
+        throw new CapabilityError('capability_source_rejected');
+    const deadline = deps.budget.reserve(urls, policy);
+    const signal = deps.signal === undefined ? deadline : AbortSignal.any([deadline, deps.signal]);
+    let admitted;
+    try {
+        admitted = await withinSignal(signal, deps.admit);
+    }
+    catch {
+        if (signal.aborted)
+            throw new CapabilityError(deps.signal?.aborted ? 'capability_cancelled' : 'capability_budget_exhausted');
+        throw new CapabilityError('capability_unavailable');
+    }
+    if (!admitted)
+        throw new CapabilityError('capability_budget_exhausted');
+    const parts = await Promise.all(urls.map(async (url, requestIndex) => {
+        try {
+            return await deps.budget.withSlot(signal, async () => {
+                const raw = await withinSignal(signal, () => deps.reader.read({
+                    url,
+                    signal,
+                    maxBytes: limits.maxPageBytes,
+                    beforeRequest: () => {
+                        signal.throwIfAborted();
+                        deps.budget.beforeRequest();
+                    },
+                    ...(domains === undefined ? {} : { domains }),
+                }));
+                const parsed = pageSchema.safeParse(raw);
+                if (!parsed.success)
+                    throw new CapabilityError('capability_result_invalid');
+                const page = parsed.data;
+                const sourceUrl = publicPageUrl(page.url, domains);
+                for (const link of page.links) {
+                    if (publicPageUrl(link.url, domains).origin !== sourceUrl.origin)
+                        throw new CapabilityError('capability_result_invalid');
+                }
+                const content = deps.budget.text(page.text, policy.maxTextBytes ?? limits.maxTextBytes);
+                const ref = `source_${requestIndex + 1}`;
+                return {
+                    item: {
+                        requestIndex,
+                        sourceRef: ref,
+                        content: { format: 'text', text: content.text },
+                        links: page.links,
+                        truncated: content.truncated,
+                    },
+                    source: {
+                        ref,
+                        url: sourceUrl.href,
+                        retrievedAt: page.retrievedAt,
+                        ...(page.title === '' ? {} : { title: page.title }),
+                    },
+                    warnings: content.truncated
+                        ? [{ requestIndex, code: 'content_truncated' }]
+                        : [],
+                };
+            });
+        }
+        catch (error) {
+            const code = error instanceof CapabilityError ? error.code : 'capability_provider_failed';
+            return { warnings: [{ requestIndex, code }] };
+        }
+    }));
+    if (signal.aborted)
+        throw new CapabilityError(deps.signal?.aborted ? 'capability_cancelled' : 'capability_budget_exhausted');
+    const items = parts.flatMap((part) => ('item' in part ? [part.item] : []));
+    const sources = parts.flatMap((part) => ('source' in part ? [part.source] : []));
+    const warnings = parts.flatMap((part) => part.warnings);
+    if (items.length === 0)
+        throw new CapabilityError('capability_provider_failed');
+    const result = webExtractResultSchema.safeParse({
+        status: warnings.length === 0 ? 'complete' : 'partial',
+        items,
+        sources,
+        warnings,
+    });
+    if (!result.success)
+        throw new CapabilityError('capability_result_invalid');
+    return result.data;
+}
+/** A late/misbehaving adapter cannot hold the caller past cancellation or the trusted deadline. */
+function withinSignal(signal, run) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener('abort', abort, { once: true });
+        Promise.resolve()
+            .then(() => {
+            signal.throwIfAborted();
+            return run();
+        })
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener('abort', abort));
+    });
+}
+//# sourceMappingURL=executor.js.map

package/node_modules/@noodle-borg/managed-capabilities/dist/limits.d.ts

@@ -0,0 +1,15 @@
+export declare const WEB_EXTRACT_LIMITS: {
+    readonly maxUrls: 5;
+    readonly maxCalls: 3;
+    readonly maxConcurrency: 2;
+    readonly maxPageBytes: number;
+    readonly maxTextBytes: number;
+    readonly maxTurnTextBytes: number;
+    readonly maxRobotsBytes: number;
+    readonly maxUrlCharacters: 2048;
+    readonly maxLinks: 30;
+    readonly maxRedirects: 2;
+    readonly maxHttpAttempts: 20;
+    readonly timeoutMs: 30000;
+};
+//# sourceMappingURL=limits.d.ts.map

package/node_modules/@noodle-borg/managed-capabilities/dist/limits.js

@@ -0,0 +1,15 @@
+export const WEB_EXTRACT_LIMITS = {
+    maxUrls: 5,
+    maxCalls: 3,
+    maxConcurrency: 2,
+    maxPageBytes: 1024 * 1024,
+    maxTextBytes: 32 * 1024,
+    maxTurnTextBytes: 128 * 1024,
+    maxRobotsBytes: 512 * 1024,
+    maxUrlCharacters: 2048,
+    maxLinks: 30,
+    maxRedirects: 2,
+    maxHttpAttempts: 20,
+    timeoutMs: 30_000,
+};
+//# sourceMappingURL=limits.js.map