@superblocksteam/vite-plugin-file-sync 2.0.59-next.0 → 2.0.59-next.10

package/dist/ai-service/agent/subagents/apis/system-prompt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"system-prompt.js","sourceRoot":"","sources":["../../../../../src/ai-service/agent/subagents/apis/system-prompt.ts"],"names":[],"mappings":"AAAA,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwpDpB,CAAC;AAEF,oEAAoE;AACpE,oBAAoB;AACpB,mBAAmB;AACnB,gDAAgD;AAChD,iBAAiB;AACjB,oBAAoB;AACpB,gBAAgB;AAChB,oCAAoC;AACpC,qCAAqC;AACrC,yBAAyB;AACzB,SAAS;AACT,OAAO;AACP,IAAI;AAEJ,eAAe,YAAY,CAAC"}

package/dist/ai-service/agent/tools/apis/finalize-api.d.ts

@@ -1,11 +0,0 @@
-export declare const finalizeApiToolFactory: import("../../tools2/types.js").ToolFactory<import("../../tools2/types.js").Tool<{
-    apiName: string;
-    summary: string;
-    responseInterface: string;
-    inputInterface: string;
-    givingUpDueToFatalError?: boolean | undefined;
-}, {
-    message: string;
-    apiName: string;
-}>>;
-//# sourceMappingURL=finalize-api.d.ts.map

package/dist/ai-service/agent/tools/apis/finalize-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"finalize-api.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/agent/tools/apis/finalize-api.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB;;;;;;;;;GAqLlC,CAAC"}

package/dist/ai-service/agent/tools/apis/finalize-api.js

@@ -1,133 +0,0 @@
-import path from "node:path";
-import { z } from "zod";
-import { ApiGenerationContext } from "../../subagents/apis/context.js";
-import { createToolFactory, ToolCategory } from "../../tools2/types.js";
-export const finalizeApiToolFactory = createToolFactory("finalizeApi", (clark, services, scopeUpdateQueue) => {
-    return {
-        category: ToolCategory.API,
-        description: `Finalize. Create a summary of the work completed.
-
-IMPORTANT: You must supply ACCURATE TypeScript interfaces for the response and input of the API based on the API source code you wrote.`,
-        inputSchema: z.object({
-            responseInterface: z
-                .string()
-                .describe("A TypeScript interface describing the expected response from the API"),
-            inputInterface: z
-                .string()
-                .describe("A TypeScript interface describing the expected input to the API"),
-            summary: z.string().describe("A summary of the API"),
-            apiName: z.string().describe("The name of the API"),
-            givingUpDueToFatalError: z
-                .boolean()
-                .optional()
-                .describe("Whether you are giving up due to a fatal error"),
-        }),
-        execute: async ({ responseInterface, inputInterface, summary, apiName, givingUpDueToFatalError, }, options) => {
-            const context = ApiGenerationContext.from(options?.experimental_context);
-            let id = apiName;
-            if (context && context.id) {
-                id = context.id;
-            }
-            const apiGenStateMap = clark.context.apiGenStateMap;
-            if (!apiGenStateMap) {
-                throw new Error("API generation state map is not initialized. This is an internal error.");
-            }
-            const state = apiGenStateMap.get(id);
-            if (!state) {
-                throw new Error(`No API generation state found for ${apiName}. This is an internal error.`);
-            }
-            if (state.status !== "built") {
-                throw new Error(`Cannot finalize API in status "${state.status}". The API must be successfully built first using the buildApi tool. Expected status: "built", current status: "${state.status}".`);
-            }
-            if (givingUpDueToFatalError) {
-                const error = new Error(`Unable to complete API generation. ${summary}`);
-                apiGenStateMap.set(id, {
-                    ...state,
-                    status: "failed",
-                    error,
-                    errorContext: {
-                        phase: "finalizing",
-                        userPrompt: summary,
-                        suggestion: "Review the error details and consider alternative approaches",
-                    },
-                });
-                throw error;
-            }
-            const { apiYaml, isNewApi } = state;
-            try {
-                // Write API YAML file
-                if (state.isNewApi) {
-                    await scopeUpdateQueue.enqueue(async () => {
-                        await services.draftInterface.createDraftFile(apiYaml.filePath, apiYaml.content);
-                    });
-                }
-                else {
-                    await services.draftInterface.createDraftFile(apiYaml.filePath, apiYaml.content);
-                }
-                const typesContent = `// Auto-generated by Clark
-// Contains input/output type definitions for ${apiName}
-
-${inputInterface}
-
-${responseInterface}
-`;
-                const apiDir = path.dirname(apiYaml.filePath);
-                const typesFilePath = path.join(apiDir, "types.d.ts");
-                if (state.isNewApi) {
-                    await scopeUpdateQueue.enqueue(async () => {
-                        await services.draftInterface.createDraftFile(typesFilePath, typesContent);
-                    });
-                }
-                else {
-                    await services.draftInterface.createDraftFile(typesFilePath, typesContent);
-                }
-            }
-            catch (error) {
-                apiGenStateMap.set(id, {
-                    ...state,
-                    status: "failed",
-                    error,
-                    errorContext: {
-                        phase: "finalizing",
-                        suggestion: "There may be an issue with file system permissions or the page configuration",
-                    },
-                });
-                throw error;
-            }
-            let message = `${summary}
-
-The API response corresponds to the following TypeScript interface:
-
-\`\`\`typescript
-${responseInterface}
-\`\`\`
-
-The API input corresponds to the following TypeScript interface:
-
-\`\`\`typescript
-${inputInterface}
-\`\`\`
-`;
-            if (isNewApi) {
-                message = `${message}
-
-The ${apiName} scope was updated to include the ${apiName} entity.
-`;
-            }
-            apiGenStateMap.set(id, {
-                ...state,
-                status: "finalized",
-                interface: {
-                    input: inputInterface,
-                    output: responseInterface,
-                },
-                message,
-            });
-            return {
-                message,
-                apiName,
-            };
-        },
-    };
-});
-//# sourceMappingURL=finalize-api.js.map

package/dist/ai-service/agent/tools/apis/finalize-api.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"finalize-api.js","sourceRoot":"","sources":["../../../../../src/ai-service/agent/tools/apis/finalize-api.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAMxE,MAAM,CAAC,MAAM,sBAAsB,GAAG,iBAAiB,CACrD,aAAa,EACb,CACE,KAAY,EACZ,QAAiC,EACjC,gBAAgC,EAChC,EAAE;IACF,OAAO;QACL,QAAQ,EAAE,YAAY,CAAC,GAAG;QAC1B,WAAW,EAAE;;wIAEqH;QAClI,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC;YACpB,iBAAiB,EAAE,CAAC;iBACjB,MAAM,EAAE;iBACR,QAAQ,CACP,sEAAsE,CACvE;YACH,cAAc,EAAE,CAAC;iBACd,MAAM,EAAE;iBACR,QAAQ,CACP,iEAAiE,CAClE;YACH,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;YACpD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,qBAAqB,CAAC;YACnD,uBAAuB,EAAE,CAAC;iBACvB,OAAO,EAAE;iBACT,QAAQ,EAAE;iBACV,QAAQ,CAAC,gDAAgD,CAAC;SAC9D,CAAC;QACF,OAAO,EAAE,KAAK,EACZ,EACE,iBAAiB,EACjB,cAAc,EACd,OAAO,EACP,OAAO,EACP,uBAAuB,GACxB,EACD,OAAO,EACP,EAAE;YACF,MAAM,OAAO,GAAG,oBAAoB,CAAC,IAAI,CACvC,OAAO,EAAE,oBAAoB,CAC9B,CAAC;YACF,IAAI,EAAE,GAAG,OAAO,CAAC;YACjB,IAAI,OAAO,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;gBAC1B,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;YAClB,CAAC;YAED,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC;YACpD,IAAI,CAAC,cAAc,EAAE,CAAC;gBACpB,MAAM,IAAI,KAAK,CACb,yEAAyE,CAC1E,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAAG,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACrC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,MAAM,IAAI,KAAK,CACb,qCAAqC,OAAO,8BAA8B,CAC3E,CAAC;YACJ,CAAC;YAED,IAAI,KAAK,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;gBAC7B,MAAM,IAAI,KAAK,CACb,kCAAkC,KAAK,CAAC,MAAM,mHAAmH,KAAK,CAAC,MAAM,IAAI,CAClL,CAAC;YACJ,CAAC;YAED,IAAI,uBAAuB,EAAE,CAAC;gBAC5B,MAAM,KAAK,GAAG,IAAI,KAAK,CACrB,sCAAsC,OAAO,EAAE,CAChD,CAAC;gBACF,cAAc,CAAC,GAAG,CAAC,EAAE,EAAE;oBACrB,GAAG,KAAK;oBACR,MAAM,EAAE,QAAQ;oBAChB,KAAK;oBACL,YAAY,EAAE;wBACZ,KAAK,EAAE,YAAY;wBACnB,UAAU,EAAE,OAAO;wBACnB,UAAU,EACR,8DAA8D;qBACjE;iBACF,CAAC,CAAC;gBACH,MAAM,KAAK,CAAC;YACd,CAAC;YAED,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;YAEpC,IAAI,CAAC;gBACH,sBAAsB;gBACtB,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;oBACnB,MAAM,gBAAgB,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE;wBACxC,MAAM,QAAQ,CAAC,cAAc,CAAC,eAAe,CAC3C,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,OAAO,CAChB,CAAC;oBACJ,CAAC,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,MAAM,QAAQ,CAAC,cAAc,CAAC,eAAe,CAC3C,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,OAAO,CAChB,CAAC;gBACJ,CAAC;gBAED,MAAM,YAAY,GAAG;gDACiB,OAAO;;EAErD,cAAc;;EAEd,iBAAiB;CAClB,CAAC;gBAEQ,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAC9C,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;gBAEtD,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;oBACnB,MAAM,gBAAgB,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE;wBACxC,MAAM,QAAQ,CAAC,cAAc,CAAC,eAAe,CAC3C,aAAa,EACb,YAAY,CACb,CAAC;oBACJ,CAAC,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,MAAM,QAAQ,CAAC,cAAc,CAAC,eAAe,CAC3C,aAAa,EACb,YAAY,CACb,CAAC;gBACJ,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,cAAc,CAAC,GAAG,CAAC,EAAE,EAAE;oBACrB,GAAG,KAAK;oBACR,MAAM,EAAE,QAAQ;oBAChB,KAAK;oBACL,YAAY,EAAE;wBACZ,KAAK,EAAE,YAAY;wBACnB,UAAU,EACR,8EAA8E;qBACjF;iBACF,CAAC,CAAC;gBACH,MAAM,KAAK,CAAC;YACd,CAAC;YAED,IAAI,OAAO,GAAG,GAAG,OAAO;;;;;EAK9B,iBAAiB;;;;;;EAMjB,cAAc;;CAEf,CAAC;YAEM,IAAI,QAAQ,EAAE,CAAC;gBACb,OAAO,GAAG,GAAG,OAAO;;MAExB,OAAO,qCAAqC,OAAO;CACxD,CAAC;YACM,CAAC;YAED,cAAc,CAAC,GAAG,CAAC,EAAE,EAAE;gBACrB,GAAG,KAAK;gBACR,MAAM,EAAE,WAAW;gBACnB,SAAS,EAAE;oBACT,KAAK,EAAE,cAAc;oBACrB,MAAM,EAAE,iBAAiB;iBAC1B;gBACD,OAAO;aACR,CAAC,CAAC;YAEH,OAAO;gBACL,OAAO;gBACP,OAAO;aACR,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC,CACF,CAAC"}

package/dist/ai-service/llm/middleware/retry.d.ts

@@ -1,112 +0,0 @@
-/**
- * Retry middleware for AI SDK language models.
- *
- * Provides automatic retry functionality for streaming operations that fail
- * due to transient network errors (e.g., timeouts). This middleware operates
- * at the LanguageModelV2 level, retrying doStream() calls with exponential
- * backoff.
- *
- * **Two-phase retry architecture:**
- * 1. **Initial call retry**: Retries HTTP-level errors when calling doStream() to get metadata
- * 2. **Stream consumption retry**: Retries mid-stream errors during stream consumption
- *
- * **Separate retry budgets:**
- * Each phase has its own independent retry budget. For example, with maxRetries: 3:
- * - Phase 1 can retry up to 3 times (4 total attempts to get initial metadata)
- * - Phase 2 can retry up to 3 times (4 total attempts to consume stream)
- * - Maximum total attempts: 4 (phase 1) + 4 (phase 2) = 8
- *
- * This design ensures that failures in one phase don't prevent retries in the other phase.
- *
- * Handles two error types:
- * 1. HTTP-level errors: doStream() throws an exception (retried in phase 1)
- * 2. Stream-level errors: error chunks in the stream or connection drops (retried in phase 2)
- *
- * **Default retry strategy: Permissive**
- * - Retries all errors except known permanent failures (auth, permission, invalid request)
- * - Handles rate limits, server overload, timeouts, network issues
- * - Future-proof: retries unknown error types
- *
- * By default, retries are unlimited but can be constrained by maxRetries and/or
- * maxTotalRetryTimeMs options.
- */
-import { type Logger } from "../../../util/logger.js";
-import { type BackoffStrategy } from "../../util/backoff-strategy.js";
-import type { LanguageModelV2Middleware } from "@ai-sdk/provider";
-import type { LLMProviderConfig } from "@superblocksteam/library-shared/types";
-export interface RetryOptions {
-    /**
-     * Maximum number of retry attempts (not including the initial attempt).
-     * Default: unlimited
-     */
-    maxRetries?: number;
-    /**
-     * Custom backoff strategy for calculating retry delays.
-     * If not provided, uses ExponentialBackoff with initialDelayMs, maxDelayMs, and backoffMultiplier.
-     */
-    backoffStrategy?: BackoffStrategy;
-    /**
-     * Initial delay in milliseconds before the first retry.
-     * Subsequent retries use exponential backoff.
-     * Only used if backoffStrategy is not provided.
-     * Default: 500 (0.5 seconds)
-     */
-    initialDelayMs?: number;
-    /**
-     * Maximum delay in milliseconds for exponential backoff.
-     * Only used if backoffStrategy is not provided.
-     * Default: 5000 (5 seconds)
-     */
-    maxDelayMs?: number;
-    /**
-     * Backoff multiplier for exponential backoff.
-     * Only used if backoffStrategy is not provided.
-     * Default: 2
-     */
-    backoffMultiplier?: number;
-    /**
-     * Maximum total time in milliseconds for all retry attempts.
-     * If retries exceed this total time, no more retries will be attempted.
-     * Default: undefined (no time limit)
-     */
-    maxTotalRetryTimeMs?: number;
-    /**
-     * Function to determine if an error is retryable.
-     * Default: checks for timeout and connection errors
-     */
-    isRetryable?: (error: unknown) => boolean;
-    /**
-     * Callback invoked before each retry attempt.
-     */
-    onRetry?: (error: unknown, attempt: number, delayMs: number, totalRetryTimeMs: number) => void | Promise<void>;
-    /**
-     * Optional abort signal to cancel retry attempts.
-     * When the signal is aborted, no further retries will be attempted.
-     */
-    abortSignal?: AbortSignal;
-}
-/**
- * Creates retry middleware for LanguageModelV2.
- *
- * This middleware wraps the doStream function and automatically retries
- * both HTTP-level errors (thrown exceptions) and stream-level errors
- * (error chunks in the stream). Retries use exponential backoff and
- * respect configured limits.
- *
- * @example
- * ```typescript
- * // Unlimited retries with 2-minute time limit
- * const middleware = retryMiddleware("bedrock", { maxTotalRetryTimeMs: 120000 });
- *
- * // Limit to 3 retries
- * const middleware = retryMiddleware("bedrock", { maxRetries: 3 });
- *
- * // Apply to model
- * const model = wrapLanguageModel({
- *   model: baseModel,
- *   middleware: [middleware]
- * });
- * ```
- */
-export declare function retryMiddleware(provider: LLMProviderConfig["provider"], options?: RetryOptions, logger?: Logger): LanguageModelV2Middleware;
-//# sourceMappingURL=retry.d.ts.map

package/dist/ai-service/llm/middleware/retry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../../src/ai-service/llm/middleware/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,KAAK,MAAM,EAA2B,MAAM,yBAAyB,CAAC;AAC/E,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,gCAAgC,CAAC;AAGxC,OAAO,KAAK,EACV,yBAAyB,EAE1B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAE/E,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAE1C;;OAEG;IACH,OAAO,CAAC,EAAE,CACR,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,KACrB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,iBAAiB,CAAC,UAAU,CAAC,EACvC,OAAO,GAAE,YAAiB,EAC1B,MAAM,GAAE,MAAoB,GAC3B,yBAAyB,CAsJ3B"}

package/dist/ai-service/llm/middleware/retry.js

@@ -1,239 +0,0 @@
-/**
- * Retry middleware for AI SDK language models.
- *
- * Provides automatic retry functionality for streaming operations that fail
- * due to transient network errors (e.g., timeouts). This middleware operates
- * at the LanguageModelV2 level, retrying doStream() calls with exponential
- * backoff.
- *
- * **Two-phase retry architecture:**
- * 1. **Initial call retry**: Retries HTTP-level errors when calling doStream() to get metadata
- * 2. **Stream consumption retry**: Retries mid-stream errors during stream consumption
- *
- * **Separate retry budgets:**
- * Each phase has its own independent retry budget. For example, with maxRetries: 3:
- * - Phase 1 can retry up to 3 times (4 total attempts to get initial metadata)
- * - Phase 2 can retry up to 3 times (4 total attempts to consume stream)
- * - Maximum total attempts: 4 (phase 1) + 4 (phase 2) = 8
- *
- * This design ensures that failures in one phase don't prevent retries in the other phase.
- *
- * Handles two error types:
- * 1. HTTP-level errors: doStream() throws an exception (retried in phase 1)
- * 2. Stream-level errors: error chunks in the stream or connection drops (retried in phase 2)
- *
- * **Default retry strategy: Permissive**
- * - Retries all errors except known permanent failures (auth, permission, invalid request)
- * - Handles rate limits, server overload, timeouts, network issues
- * - Future-proof: retries unknown error types
- *
- * By default, retries are unlimited but can be constrained by maxRetries and/or
- * maxTotalRetryTimeMs options.
- */
-import { getErrorMeta, getLogger } from "../../../util/logger.js";
-import { ExponentialBackoff, } from "../../util/backoff-strategy.js";
-import { LLMProviderError } from "../error.js";
-import { isProviderErrorRetryable } from "../util/provider-errors.js";
-/**
- * Creates retry middleware for LanguageModelV2.
- *
- * This middleware wraps the doStream function and automatically retries
- * both HTTP-level errors (thrown exceptions) and stream-level errors
- * (error chunks in the stream). Retries use exponential backoff and
- * respect configured limits.
- *
- * @example
- * ```typescript
- * // Unlimited retries with 2-minute time limit
- * const middleware = retryMiddleware("bedrock", { maxTotalRetryTimeMs: 120000 });
- *
- * // Limit to 3 retries
- * const middleware = retryMiddleware("bedrock", { maxRetries: 3 });
- *
- * // Apply to model
- * const model = wrapLanguageModel({
- *   model: baseModel,
- *   middleware: [middleware]
- * });
- * ```
- */
-export function retryMiddleware(provider, options = {}, logger = getLogger()) {
-    const maxRetries = options.maxRetries ?? Infinity;
-    const isRetryable = options.isRetryable ?? isProviderErrorRetryable;
-    const maxTotalRetryTimeMs = options.maxTotalRetryTimeMs;
-    const onRetry = options.onRetry;
-    const backoffStrategy = options.backoffStrategy ??
-        new ExponentialBackoff({
-            initialDelayMs: options.initialDelayMs ?? 500,
-            maxDelayMs: options.maxDelayMs ?? 5000,
-            backoffMultiplier: options.backoffMultiplier ?? 2,
-        });
-    // Format maxRetries for display
-    const maxRetriesDisplay = maxRetries === Infinity ? "unlimited" : String(maxRetries);
-    const retryConfig = {
-        provider,
-        maxRetries,
-        maxRetriesDisplay,
-        maxTotalRetryTimeMs,
-        backoffStrategy,
-        isRetryable,
-        onRetry,
-        abortSignal: options.abortSignal,
-        logger,
-    };
-    return {
-        wrapStream: async ({ doStream }) => {
-            // First retry loop: Get initial result with metadata
-            // This retries HTTP-level errors from doStream() call
-            let attempt = 0;
-            let totalRetryTime = 0;
-            let initialResult;
-            while (true) {
-                try {
-                    initialResult = await doStream();
-                    break; // Success!
-                }
-                catch (err) {
-                    attempt++;
-                    const delay = await handleRetryAttempt(err, attempt, totalRetryTime, {
-                        ...retryConfig,
-                        errorContext: "HTTP error",
-                    });
-                    totalRetryTime += delay;
-                }
-            }
-            // Second retry loop: Handle stream consumption errors
-            // This retries mid-stream errors (connection drops, timeouts)
-            const retryingStream = new ReadableStream({
-                async start(controller) {
-                    let consumptionAttempt = 0;
-                    let consumptionRetryTime = 0;
-                    let isFirstAttempt = true;
-                    while (true) {
-                        let reader = null;
-                        let error;
-                        try {
-                            // First attempt: reuse initial stream
-                            // Subsequent attempts: call doStream() fresh
-                            const streamResult = isFirstAttempt
-                                ? initialResult
-                                : await doStream();
-                            isFirstAttempt = false;
-                            reader = streamResult.stream.getReader();
-                            // Read and forward chunks
-                            while (true) {
-                                const { value: chunk, done } = await reader.read();
-                                if (done) {
-                                    controller.close();
-                                    return; // Success!
-                                }
-                                // Check for error chunks
-                                if (chunk.type === "error") {
-                                    throw new LLMProviderError({
-                                        provider,
-                                        cause: chunk.error,
-                                    });
-                                }
-                                // Normal chunk - forward it
-                                controller.enqueue(chunk);
-                                // Reset consumption attempt on successful chunk
-                                consumptionAttempt = 0;
-                                consumptionRetryTime = 0;
-                            }
-                        }
-                        catch (err) {
-                            // Release reader before retry
-                            if (reader) {
-                                try {
-                                    reader.releaseLock();
-                                }
-                                catch {
-                                    // Ignore errors during release
-                                }
-                            }
-                            error =
-                                err instanceof LLMProviderError
-                                    ? err
-                                    : new LLMProviderError({ provider, cause: err });
-                        }
-                        // Handle error - check if we should retry
-                        consumptionAttempt++;
-                        try {
-                            const delay = await handleRetryAttempt(error, consumptionAttempt, consumptionRetryTime, {
-                                ...retryConfig,
-                                errorContext: "Stream error",
-                            });
-                            consumptionRetryTime += delay;
-                        }
-                        catch (finalError) {
-                            // Exhausted or non-retryable - pass error through and close
-                            controller.enqueue({
-                                type: "error",
-                                error: finalError,
-                            });
-                            controller.close();
-                            return;
-                        }
-                        // Loop continues - will call doStream() again
-                    }
-                },
-            });
-            // Return metadata from initial result with retrying stream
-            return {
-                ...initialResult,
-                stream: retryingStream,
-            };
-        },
-    };
-}
-/**
- * Checks if an error can be retried and returns appropriate error handling info.
- */
-function checkRetryability(error, attempt, maxRetries, maxRetriesDisplay, totalRetryTime, maxTotalRetryTimeMs, isRetryable, logger) {
-    const withinMaxRetries = attempt <= maxRetries;
-    const withinTimeLimit = !maxTotalRetryTimeMs || totalRetryTime < maxTotalRetryTimeMs;
-    const canRetry = isRetryable(error) && withinMaxRetries && withinTimeLimit;
-    if (!canRetry) {
-        const reason = !isRetryable(error)
-            ? `not retryable (type: ${error.type})`
-            : !withinMaxRetries
-                ? `after ${maxRetriesDisplay} retries`
-                : `total retry time exceeded ${maxTotalRetryTimeMs}ms`;
-        const message = `Stream error ${reason}`;
-        error.message = message;
-        logger.error(message, getErrorMeta(error.cause));
-        return { canRetry: false, errorToThrow: error };
-    }
-    return { canRetry: true };
-}
-/**
- * Executes retry logic for a single attempt including error wrapping, backoff, logging, and callbacks.
- * Returns the delay in milliseconds if a retry should be attempted, or throws if no retry is possible.
- */
-async function handleRetryAttempt(err, attempt, totalRetryTime, config) {
-    const error = err instanceof LLMProviderError
-        ? err
-        : new LLMProviderError({ provider: config.provider, cause: err });
-    const retryCheck = checkRetryability(error, attempt, config.maxRetries, config.maxRetriesDisplay, totalRetryTime, config.maxTotalRetryTimeMs, config.isRetryable, config.logger);
-    if (!retryCheck.canRetry) {
-        throw retryCheck.errorToThrow;
-    }
-    // Check if abort signal was triggered
-    if (config.abortSignal?.aborted) {
-        const abortError = new LLMProviderError({
-            message: "Request aborted",
-            provider: config.provider,
-            aborted: true,
-        });
-        config.logger.info("Request aborted, stopping retry attempts");
-        throw abortError;
-    }
-    const delay = config.backoffStrategy.getNextDelay(attempt);
-    config.logger.warn(`${config.errorContext} (type: ${error.type}). Attempt ${attempt}/${config.maxRetriesDisplay}. Retrying in ${delay}ms...`);
-    if (config.onRetry) {
-        await config.onRetry(error, attempt, delay, totalRetryTime);
-    }
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    return delay;
-}
-//# sourceMappingURL=retry.js.map

package/dist/ai-service/llm/middleware/retry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../../../src/ai-service/llm/middleware/retry.ts"],"names":[],"mappings":"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"}