drizzle-cube 0.5.8 → 0.6.1

package/dist/server/logical-plan/cte-planner-helpers.d.ts

@@ -0,0 +1,37 @@
+import { Cube, CubeJoin, SemanticQuery } from '../types/index.js';
+/** A resolved CTE join key (column names plus the underlying column objects). */
+export interface CTEJoinKey {
+    sourceColumn: string;
+    targetColumn: string;
+    sourceColumnObj: any;
+    targetColumnObj: any;
+}
+/** A join definition located relative to a primary/target cube pair. */
+export interface FoundJoinInfo {
+    sourceCube: Cube;
+    joinDef: CubeJoin;
+    reversed?: boolean;
+}
+/**
+ * Derive the CTE join keys for a located join definition, handling
+ * belongsToMany junctions and reversed (belongsTo-back-to-primary) joins.
+ */
+export declare function deriveCTEJoinKeys(joinInfo: FoundJoinInfo, primaryCube: Cube): CTEJoinKey[];
+/**
+ * Derive the join keys connecting a downstream dimension cube through the CTE
+ * cube, handling belongsToMany (via junction sourceKey) and regular joins.
+ */
+export declare function deriveDownstreamJoinKeys(joinDef: CubeJoin): CTEJoinKey[];
+/**
+ * Find join information for a target cube, searching (in priority order):
+ * 1. The primary cube's direct join to the target.
+ * 2. The target cube's join back to the primary (reverse lookup → reversed).
+ * 3. Any other registered cube's join to the target.
+ */
+export declare function findJoinInfoForCube(cubes: Map<string, Cube>, primaryCube: Cube, targetCubeName: string): FoundJoinInfo | null;
+/**
+ * Collect the names of cubes (other than the CTE cube) that contribute
+ * dimensions, time dimensions, or filter members to the query. These are the
+ * candidate downstream cubes that may need to join through the CTE.
+ */
+export declare function collectDimensionCubeNames(query: SemanticQuery, cteCubeName: string): Set<string>;

package/dist/server/logical-plan/cte-planner.d.ts

@@ -0,0 +1,104 @@
+import { Cube, QueryContext, PhysicalQueryPlan, SemanticQuery } from '../types/index.js';
+import { ResolverCache } from './planner-utils.js';
+import { FilterPropagation } from './filter-propagation.js';
+import { JoinRef } from './types.js';
+export declare class CTEPlanner {
+    private readonly resolverCache;
+    private readonly filterPropagation;
+    constructor(resolverCache: ResolverCache, filterPropagation: FilterPropagation);
+    /**
+     * Plan pre-aggregation CTEs for hasMany relationships to prevent fan-out
+     * Note: belongsToMany relationships handle fan-out differently through their junction table structure
+     * and don't require CTEs - the two-hop join with the junction table provides natural grouping
+     *
+     * CRITICAL FAN-OUT PREVENTION LOGIC:
+     * When a query contains ANY hasMany relationship in the join graph, ALL cubes with measures
+     * that could be affected by row multiplication need CTEs. This includes:
+     *
+     * 1. Cubes with direct hasMany FROM primary (existing logic)
+     * 2. Cubes with measures that would be multiplied due to hasMany elsewhere in the query
+     *    - Example: Query has Departments.totalBudget + Productivity.recordCount
+     *    - Employees hasMany → Productivity causes row multiplication
+     *    - Departments.totalBudget would be inflated without CTE pre-aggregation
+     */
+    planPreAggregationCTEs(cubes: Map<string, Cube>, primaryCube: Cube, joinCubes: JoinRef[], query: SemanticQuery, _ctx: QueryContext): PhysicalQueryPlan['preAggregationCTEs'];
+    /**
+     * Build a single pre-aggregation CTE for one join-cube entry, or return null
+     * when the cube contributes no aggregate measures / has no resolvable join.
+     */
+    private buildCTEForJoinCube;
+    /**
+     * Resolve the join keys (and any intermediate joins to absorb) for a CTE cube.
+     *
+     * Analyses the path from primary to the CTE cube: if an intermediate hasMany
+     * exists, returns the corrected keys plus intermediate joins; otherwise locates
+     * the join definition and derives keys from it.
+     */
+    private resolveCTEJoinKeys;
+    /**
+     * Locate the join definition for a CTE cube, preferring the final step of the
+     * analysed path and falling back to a primary/reverse/any-cube search.
+     */
+    private locateJoinInfo;
+    /**
+     * Analyze the join path from primary cube to a target CTE cube.
+     * Detects if there are intermediate hasMany relationships that would cause fan-out.
+     *
+     * Returns information about:
+     * - The full join path
+     * - Whether there are hasMany relationships ON the path (not just at the end)
+     * - Which intermediate tables need to be absorbed into the CTE
+     * - The correct join key to use (from primary cube's connection point)
+     *
+     * @param cubes Map of all registered cubes
+     * @param primaryCube The primary cube (FROM clause)
+     * @param targetCubeName The CTE cube we're analyzing the path to
+     * @param query The semantic query (drives query-aware path selection)
+     */
+    private analyzeJoinPathToPrimary;
+    /**
+     * Compute CTE reasons from the actual join plan entries.
+     *
+     * Instead of scanning all registered cubes (which causes false positives when
+     * unrelated hasMany relationships exist), this walks only the planned joins
+     * using the `relationship` field now stored on each JoinCubePlanEntry.
+     *
+     * Algorithm:
+     * 1. Scan join plan entries for hasMany/belongsToMany relationships
+     * 2. If none found → return empty map (no CTEs needed)
+     * 3. hasMany/belongsToMany targets with measures → 'hasMany'
+     * 4. Other join cubes with measures (not hasMany source) → 'fanOutPrevention'
+     */
+    private computeCTEReasons;
+    /**
+     * Find downstream cubes that need join keys included in the CTE.
+     *
+     * When a query has dimensions from a cube (e.g., Teams.name) and measures from
+     * a junction cube (e.g., EmployeeTeams.count), the junction CTE needs to include
+     * the join key to the dimension cube (team_id) so the dimension cube can be
+     * joined through the CTE instead of via an alternative path.
+     *
+     * @param cteCube The cube being converted to a CTE (e.g., EmployeeTeams)
+     * @param query The semantic query with dimensions and measures
+     * @param allCubes Map of all registered cubes
+     * @returns Array of downstream join key info for cubes needing join through this CTE
+     */
+    private findDownstreamJoinKeys;
+    /**
+     * Expand calculated measures to include their dependencies
+     */
+    private expandCalculatedMeasureDependencies;
+    /**
+     * Extract measure references from calculatedSql template
+     */
+    private extractDependenciesFromTemplate;
+    /**
+     * Extract measures referenced in filters (for CTE inclusion)
+     */
+    private extractMeasuresFromFilters;
+    /**
+     * Recursively extract measures from filters for a specific cube
+     * Only includes filter members that are actually measures (not dimensions)
+     */
+    private extractMeasuresFromFilter;
+}

package/dist/server/logical-plan/filter-propagation.d.ts

@@ -0,0 +1,44 @@
+import { Cube, SemanticQuery, PropagatingFilter, Filter } from '../types/index.js';
+export declare class FilterPropagation {
+    /**
+     * Find filters that need to propagate from related cubes to a CTE cube.
+     * When cube A has filters and a hasMany relationship to cube B (the CTE cube),
+     * A's filters should propagate into B's CTE via a subquery.
+     *
+     * Example: Employees.createdAt filter should propagate to Productivity CTE
+     * via: employee_id IN (SELECT id FROM employees WHERE created_at >= $date)
+     */
+    findPropagatingFilters(query: SemanticQuery, cteCube: Cube, allCubes: Map<string, Cube>): PropagatingFilter[];
+    /**
+     * Collect cube names referenced by filters and by time-dimension date ranges.
+     */
+    private collectFilterCubeNames;
+    /**
+     * Build a single PropagatingFilter for a filterCube → cteCube hasMany edge,
+     * or null when the cube contributes no filters / the join has no keys.
+     */
+    private buildPropagatingFilter;
+    /**
+     * Extract cube names from filters into a Set (helper for findPropagatingFilters)
+     */
+    extractFilterCubeNamesToSet(filters: Filter[], cubesSet: Set<string>): void;
+    /**
+     * Extract filters for a specific cube from the filter array
+     *
+     * Logic for preserving filter semantics:
+     * - AND: Safe to extract only matching branches (AND of fewer conditions is more permissive)
+     * - OR: Must include ALL branches or skip entirely (partial OR changes semantics)
+     *       If any branch belongs to another cube, skip the entire OR to be safe
+     *       since we can't evaluate the other cube's conditions
+     */
+    extractFiltersForCube(filters: Filter[], targetCubeName: string): Filter[];
+    /**
+     * Check if all simple filters in a filter array belong to the specified cube
+     * Recursively checks nested AND/OR filters
+     */
+    allFiltersFromCube(filters: Filter[], targetCubeName: string): boolean;
+    /**
+     * Extract time dimension date range filters as regular filters for a specific cube
+     */
+    extractTimeDimensionFiltersForCube(query: SemanticQuery, targetCubeName: string): Filter[];
+}

package/dist/server/{server/logical-plan → logical-plan}/index.d.ts

@@ -6,9 +6,14 @@
  * - LogicalPlanBuilder: SemanticQuery → LogicalNode tree
  * - Optimisers: PlanOptimiser interface and built-in passes
  */
-export type { LogicalNode, LogicalNodeType, LogicalNodeBase, QueryNode, SimpleSource, FullKeyAggregate, CTEPreAggregate, KeysDeduplication, MultiFactMerge, CubeRef, MeasureRef, DimensionRef, TimeDimensionRef, ColumnRef, OrderByRef, JoinRef, LogicalSchema } from './types';
-export { LogicalPlanner } from './logical-planner';
-export { LogicalPlanBuilder } from './logical-plan-builder';
-export type { LogicalPlanWithAnalysis } from './logical-plan-builder';
-export type { PlanOptimiser, OptimiserContext } from './optimiser';
-export { IdentityOptimiser, OptimiserPipeline } from './optimiser';
+export type { LogicalNode, LogicalNodeType, LogicalNodeBase, QueryNode, SimpleSource, FullKeyAggregate, CTEPreAggregate, KeysDeduplication, MultiFactMerge, CubeRef, MeasureRef, DimensionRef, TimeDimensionRef, ColumnRef, OrderByRef, JoinRef, LogicalSchema } from './types.js';
+export { LogicalPlanner } from './logical-planner.js';
+export { LogicalPlanBuilder } from './logical-plan-builder.js';
+export type { LogicalPlanWithAnalysis } from './logical-plan-builder.js';
+export { JoinPlanner } from './join-planner.js';
+export { CTEPlanner } from './cte-planner.js';
+export { FilterPropagation } from './filter-propagation.js';
+export { PlanAnalysisReporter } from './plan-analysis-reporter.js';
+export { ResolverCache, analyzeCubeUsage, extractCubeNamesFromFilter } from './planner-utils.js';
+export type { PlanOptimiser, OptimiserContext, OptimiserEngineType } from './optimiser.js';
+export { IdentityOptimiser, OptimiserPipeline } from './optimiser.js';

package/dist/server/logical-plan/join-planner.d.ts

@@ -0,0 +1,27 @@
+import { Cube, CubeJoin, SemanticQuery } from '../types/index.js';
+import { ResolverCache } from './planner-utils.js';
+import { JoinRef } from './types.js';
+export declare class JoinPlanner {
+    private readonly resolverCache;
+    constructor(resolverCache: ResolverCache);
+    /**
+     * Build join plan for multi-cube query
+     * Supports both direct joins and transitive joins through intermediate cubes
+     *
+     * Uses query-aware path selection to prefer joining through cubes that have
+     * measures in the query (e.g., joining Teams through EmployeeTeams when
+     * EmployeeTeams.count is a measure)
+     */
+    buildJoinPlan(cubes: Map<string, Cube>, primaryCube: Cube, cubeNames: string[], _ctx: unknown, query: SemanticQuery): JoinRef[];
+    /**
+     * Build a single symbolic JoinRef for a join-path step. Handles belongsToMany
+     * (junction-table) joins and regular (belongsTo/hasOne/hasMany) joins. The join
+     * conditions and security WHERE are materialized later by DrizzlePlanBuilder;
+     * only the join type is resolved here (it depends on the effective relationship).
+     */
+    private buildJoinRef;
+    /**
+     * Find hasMany join definition from primary cube to target cube
+     */
+    findHasManyJoinDef(primaryCube: Cube, targetCubeName: string, cubes?: Map<string, Cube>): CubeJoin | null;
+}

package/dist/server/{server/logical-plan → logical-plan}/logical-plan-builder.d.ts

@@ -1,8 +1,8 @@
-import { Cube, QueryContext } from '../types';
-import { QueryAnalysis } from '../types/analysis';
-import { SemanticQuery } from '../types/query';
-import { LogicalPlanner } from './logical-planner';
-import { QueryNode } from './types';
+import { Cube, QueryContext } from '../types/index.js';
+import { QueryAnalysis } from '../types/analysis.js';
+import { SemanticQuery } from '../types/query.js';
+import { LogicalPlanner } from './logical-planner.js';
+import { QueryNode } from './types.js';
 export interface LogicalPlanWithAnalysis {
     plan: QueryNode;
     analysis: QueryAnalysis;

package/dist/server/logical-plan/logical-planner.d.ts

@@ -0,0 +1,39 @@
+import { Cube, QueryContext, PhysicalQueryPlan, SemanticQuery, PrimaryCubeAnalysis, JoinPathAnalysis, QueryWarning } from '../types/index.js';
+import { JoinRef } from './types.js';
+export declare class LogicalPlanner {
+    private readonly resolverCache;
+    private readonly joinPlanner;
+    private readonly ctePlanner;
+    private readonly reporter;
+    /**
+     * Analyze a semantic query to determine which cubes are involved
+     */
+    analyzeCubeUsage(query: SemanticQuery): Set<string>;
+    /**
+     * Analyze primary cube selection with candidate details.
+     * Exposed for LogicalPlanBuilder so dry-run/analyze can report
+     * exactly which selection rule was used.
+     */
+    analyzePrimaryCube(cubeNames: string[], query: SemanticQuery, cubes: Map<string, Cube>): PrimaryCubeAnalysis;
+    /**
+     * Analyze join path for a specific target cube.
+     * Exposed for LogicalPlanBuilder to provide join decision trace.
+     */
+    analyzeJoinPathForTarget(cubes: Map<string, Cube>, fromCube: string, toCube: string, query?: SemanticQuery): JoinPathAnalysis;
+    /**
+     * Build join plan for a known primary cube.
+     * Exposed for LogicalPlanBuilder so logical planning can compose
+     * planner phases directly.
+     */
+    buildJoinPlanForPrimary(cubes: Map<string, Cube>, primaryCube: Cube, cubeNames: string[], ctx: QueryContext, query: SemanticQuery): JoinRef[];
+    /**
+     * Build pre-aggregation CTE plan from a primary cube and join plan.
+     * Exposed for LogicalPlanBuilder phase composition.
+     */
+    buildPreAggregationCTEs(cubes: Map<string, Cube>, primaryCube: Cube, joinCubes: JoinRef[], query: SemanticQuery, ctx: QueryContext): PhysicalQueryPlan['preAggregationCTEs'];
+    /**
+     * Generate query warnings from pre-aggregation analysis.
+     * Exposed for LogicalPlanBuilder phase composition.
+     */
+    buildWarnings(query: SemanticQuery, preAggregationCTEs?: PhysicalQueryPlan['preAggregationCTEs']): QueryWarning[];
+}

package/dist/server/{server/logical-plan → logical-plan}/optimiser.d.ts

@@ -1,8 +1,10 @@
-import { LogicalNode } from './types';
+import { LogicalNode } from './types.js';
+/** Database engine the optimiser is targeting (all 7 supported engines). */
+export type OptimiserEngineType = 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
 /** Context available to optimiser passes */
 export interface OptimiserContext {
     /** Database engine type for engine-specific rewrites */
-    engineType: 'postgres' | 'mysql' | 'sqlite' | 'duckdb';
+    engineType: OptimiserEngineType;
 }
 /** A single optimiser pass that rewrites a logical plan */
 export interface PlanOptimiser {

package/dist/server/logical-plan/plan-analysis-reporter.d.ts

@@ -0,0 +1,59 @@
+import { Cube, PhysicalQueryPlan, SemanticQuery, PrimaryCubeAnalysis, JoinPathAnalysis, QueryWarning } from '../types/index.js';
+import { ResolverCache } from './planner-utils.js';
+export declare class PlanAnalysisReporter {
+    private readonly resolverCache;
+    constructor(resolverCache: ResolverCache);
+    /**
+     * Analyze why a particular cube was chosen as primary
+     */
+    analyzePrimaryCubeSelection(cubeNames: string[], query: SemanticQuery, cubes: Map<string, Cube>): PrimaryCubeAnalysis;
+    /**
+     * Build the scored candidate list (dimension count, join count, reachability).
+     */
+    private buildPrimaryCubeCandidates;
+    /**
+     * Tier 1: select the cube with the most query dimensions that can reach all
+     * others. Returns null when no dimension-based winner applies.
+     */
+    private selectByDimensions;
+    /**
+     * Tier 2: among cubes that can reach all others, select the most connected.
+     * Returns null when no candidate can reach all others.
+     */
+    private selectByConnectivity;
+    /**
+     * Analyze the join path between two cubes with detailed step information
+     *
+     * Uses JoinPathResolver.findPath() for the actual path finding,
+     * then converts the result to human-readable analysis format.
+     */
+    analyzeJoinPath(cubes: Map<string, Cube>, fromCube: string, toCube: string, query?: SemanticQuery): JoinPathAnalysis;
+    private convertInternalPathToJoinPathSteps;
+    private buildJoinPathSelectionAnalysis;
+    private mapPreferredCandidate;
+    /**
+     * Generate warnings for query edge cases that users should be aware of.
+     * Currently detects:
+     * - FAN_OUT_NO_DIMENSIONS: Query has hasMany CTEs but no dimensions to group by
+     *
+     * Note: AVG measures in hasMany CTEs can produce mathematically imprecise results
+     * (average of averages vs weighted average), but this warning was removed as it
+     * fired too aggressively. The issue only occurs when the outer grouping is coarser
+     * than the CTE grouping, which is rare in practice. The limitation is documented
+     * in executor.ts comments.
+     */
+    generateWarnings(query: SemanticQuery, preAggregationCTEs?: PhysicalQueryPlan['preAggregationCTEs']): QueryWarning[];
+    /**
+     * Detect when a query has measures from multiple cubes with hasMany relationships
+     * but no dimensions to provide grouping context.
+     *
+     * This is an edge case where:
+     * - Query has measures from 2+ cubes
+     * - At least one CTE exists (indicating hasMany relationship)
+     * - Query has NO dimensions AND NO time dimensions with granularity
+     *
+     * The SQL is technically correct (CTEs with GROUP BY on join keys), but users
+     * may be confused by the aggregated results without visible grouping.
+     */
+    private checkFanOutNoDimensions;
+}

package/dist/server/logical-plan/planner-utils.d.ts

@@ -0,0 +1,20 @@
+import { Cube, SemanticQuery } from '../types/index.js';
+import { JoinPathResolver } from '../resolvers/join-path-resolver.js';
+/**
+ * Caches a JoinPathResolver per cubes map to avoid repeated instantiation.
+ * Shared by all sub-planners so a single query reuses one resolver per cubes map.
+ */
+export declare class ResolverCache {
+    private cache;
+    get(cubes: Map<string, Cube>): JoinPathResolver;
+}
+/**
+ * Analyze a semantic query to determine which cubes are involved.
+ * Scans measures, dimensions, time dimensions, filters and ORDER BY members.
+ */
+export declare function analyzeCubeUsage(query: SemanticQuery): Set<string>;
+/**
+ * Recursively extract cube names from a filter (handles logical AND/OR filters)
+ * into the provided set.
+ */
+export declare function extractCubeNamesFromFilter(filter: any, cubesUsed: Set<string>): void;

package/dist/server/{server/logical-plan → logical-plan}/types.d.ts

@@ -1,7 +1,7 @@
-import { SQL, AnyColumn, Table } from 'drizzle-orm';
-import { Cube, JoinKeyInfo, PropagatingFilter, IntermediateJoinInfo, DownstreamJoinKeyInfo } from '../types/cube';
-import { Filter } from '../types/query';
-import { SecurityContext, QueryWarning, TimeGranularity } from '../types/core';
+import { AnyColumn, Table } from 'drizzle-orm';
+import { Cube, CubeJoin, JoinKeyInfo, PropagatingFilter, IntermediateJoinInfo, DownstreamJoinKeyInfo } from '../types/cube.js';
+import { Filter } from '../types/query.js';
+import { QueryWarning, TimeGranularity } from '../types/core.js';
 /** Reference to a registered cube */
 export interface CubeRef {
     /** Cube name (e.g. 'Employees') */
@@ -59,19 +59,25 @@ export interface JoinRef {
     target: CubeRef;
     /** Table alias in the generated SQL */
     alias: string;
-    /** SQL join type */
+    /** SQL join type (already resolved from the effective relationship) */
     joinType: 'inner' | 'left' | 'right' | 'full';
-    /** Drizzle SQL join condition (pre-built by the planner) */
-    joinCondition: SQL;
+    /**
+     * Symbolic join definition. The Drizzle join condition is materialized from
+     * this by DrizzlePlanBuilder — the logical plan itself holds no SQL and no
+     * baked security context.
+     */
+    joinDef: CubeJoin;
     /** Relationship type from the join definition */
     relationship?: 'belongsTo' | 'hasOne' | 'hasMany' | 'belongsToMany';
-    /** Junction table for belongsToMany relationships */
+    /**
+     * Junction table for belongsToMany relationships (symbolic).
+     * The junction join condition and security WHERE are materialized from
+     * `joinDef.through` by DrizzlePlanBuilder at physical-plan time.
+     */
     junctionTable?: {
         table: Table;
         alias: string;
         joinType: 'inner' | 'left' | 'right' | 'full';
-        joinCondition: SQL;
-        securitySql?: (securityContext: SecurityContext) => SQL | SQL[];
         sourceCubeName?: string;
     };
 }
@@ -102,6 +108,8 @@ export interface QueryNode extends LogicalNodeBase {
     orderBy: OrderByRef[];
     limit?: number;
     offset?: number;
+    /** When true, skip GROUP BY (raw rows) */
+    ungrouped?: boolean;
     /** Planning warnings surfaced to the caller */
     warnings: QueryWarning[];
 }

package/dist/server/measure-classification.d.ts

@@ -0,0 +1,40 @@
+import { Cube } from './types/index.js';
+/**
+ * Measure types that are window functions. Window functions require special
+ * handling: no GROUP BY in the CTE, no re-aggregation in the outer query, and
+ * they return individual rows rather than grouped results.
+ */
+export declare const WINDOW_FUNCTION_TYPES: readonly ["lag", "lead", "rank", "denseRank", "rowNumber", "ntile", "firstValue", "lastValue", "movingAvg", "movingSum"];
+/** Check if a measure type is a window function. */
+export declare function isWindowFunction(measureType: string): boolean;
+/**
+ * Check if a measure is a post-aggregation window function.
+ * Post-aggregation windows reference a base `measure` in their windowConfig,
+ * indicating they operate on aggregated data rather than raw rows.
+ */
+export declare function isPostAggregationWindow(measure: any): boolean;
+/**
+ * Resolve the base-measure reference for a post-aggregation window function to a
+ * fully qualified name (e.g. 'totalRevenue' -> 'Sales.totalRevenue').
+ * Returns null when the measure is not a post-aggregation window.
+ */
+export declare function getWindowBaseMeasure(measure: any, cubeName: string): string | null;
+/**
+ * Default operation for a window function type.
+ * - lag/lead default to 'difference' (compare current vs previous/next)
+ * - all others default to 'raw'
+ */
+export declare function getDefaultWindowOperation(windowType: string): 'raw' | 'difference' | 'ratio' | 'percentChange';
+/**
+ * Categorize measures for post-aggregation window-function handling.
+ * - aggregateMeasures: regular aggregates (count, sum, avg, etc.)
+ * - postAggWindowMeasures: window functions referencing a base measure
+ * - requiredBaseMeasures: base measures those windows depend on (auto-added)
+ */
+export declare function categorizeForPostAggregation(measureNames: string[], cubeMap: Map<string, Cube>): {
+    aggregateMeasures: string[];
+    postAggWindowMeasures: string[];
+    requiredBaseMeasures: Set<string>;
+};
+/** Whether any measure in the list is a post-aggregation window function. */
+export declare function hasPostAggregationWindows(measureNames: string[], cubeMap: Map<string, Cube>): boolean;

package/dist/server/{openai-BZdAA7Ji.js → openai-cDlFSTk6.js}

@@ -1,5 +1,62 @@
 //#region src/server/agent/providers/openai.ts
-var e = class {
+function* e(e, t) {
+	let n = e.index ?? 0;
+	if (e.id && (t.set(n, {
+		id: e.id,
+		name: e.function?.name || "",
+		arguments: ""
+	}), yield {
+		type: "tool_use_start",
+		id: e.id,
+		name: e.function?.name || ""
+	}), e.function?.name && t.has(n)) {
+		let r = t.get(n);
+		r.name ||= e.function.name;
+	}
+	if (e.function?.arguments) {
+		let r = t.get(n);
+		r && (r.arguments += e.function.arguments, yield {
+			type: "tool_input_delta",
+			json: e.function.arguments
+		});
+	}
+}
+function* t(e, t) {
+	for (let [e, n] of t) {
+		let r = {};
+		try {
+			n.arguments && (r = JSON.parse(n.arguments));
+		} catch {}
+		yield {
+			type: "tool_use_end",
+			id: n.id,
+			input: r
+		}, t.delete(e);
+	}
+	yield {
+		type: "message_meta",
+		stopReason: e
+	};
+}
+function* n(n, r) {
+	n.usage && (yield {
+		type: "message_meta",
+		inputTokens: n.usage.prompt_tokens,
+		outputTokens: n.usage.completion_tokens,
+		stopReason: ""
+	});
+	let i = n.choices?.[0];
+	if (!i) return;
+	let a = i.delta;
+	if (a) {
+		if (a.content && (yield {
+			type: "text_delta",
+			text: a.content
+		}), a.tool_calls) for (let t of a.tool_calls) yield* e(t, r);
+		i.finish_reason && (yield* t(i.finish_reason, r));
+	}
+}
+var r = class {
 	client;
 	apiKey;
 	baseURL;
@@ -36,62 +93,7 @@ var e = class {
 	}
 	async *parseStreamEvents(e) {
 		let t = /* @__PURE__ */ new Map();
-		for await (let n of e) {
-			let e = n;
-			e.usage && (yield {
-				type: "message_meta",
-				inputTokens: e.usage.prompt_tokens,
-				outputTokens: e.usage.completion_tokens,
-				stopReason: ""
-			});
-			let r = e.choices?.[0];
-			if (!r) continue;
-			let i = r.delta;
-			if (i) {
-				if (i.content && (yield {
-					type: "text_delta",
-					text: i.content
-				}), i.tool_calls) for (let e of i.tool_calls) {
-					let n = e.index ?? 0;
-					if (e.id && (t.set(n, {
-						id: e.id,
-						name: e.function?.name || "",
-						arguments: ""
-					}), yield {
-						type: "tool_use_start",
-						id: e.id,
-						name: e.function?.name || ""
-					}), e.function?.name && t.has(n)) {
-						let r = t.get(n);
-						r.name ||= e.function.name;
-					}
-					if (e.function?.arguments) {
-						let r = t.get(n);
-						r && (r.arguments += e.function.arguments, yield {
-							type: "tool_input_delta",
-							json: e.function.arguments
-						});
-					}
-				}
-				if (r.finish_reason) {
-					for (let [e, n] of t) {
-						let r = {};
-						try {
-							n.arguments && (r = JSON.parse(n.arguments));
-						} catch {}
-						yield {
-							type: "tool_use_end",
-							id: n.id,
-							input: r
-						}, t.delete(e);
-					}
-					yield {
-						type: "message_meta",
-						stopReason: r.finish_reason
-					};
-				}
-			}
-		}
+		for await (let r of e) yield* n(r, t);
 	}
 	formatTools(e) {
 		return e.map((e) => ({
@@ -150,4 +152,4 @@ var e = class {
 	}
 };
 //#endregion
-export { e as OpenAIProvider };
+export { r as OpenAIProvider };

package/dist/server/openai-vXvLni8v.cjs

@@ -0,0 +1 @@
+function*e(e,t){let n=e.index??0;if(e.id&&(t.set(n,{id:e.id,name:e.function?.name||``,arguments:``}),yield{type:`tool_use_start`,id:e.id,name:e.function?.name||``}),e.function?.name&&t.has(n)){let r=t.get(n);r.name||=e.function.name}if(e.function?.arguments){let r=t.get(n);r&&(r.arguments+=e.function.arguments,yield{type:`tool_input_delta`,json:e.function.arguments})}}function*t(e,t){for(let[e,n]of t){let r={};try{n.arguments&&(r=JSON.parse(n.arguments))}catch{}yield{type:`tool_use_end`,id:n.id,input:r},t.delete(e)}yield{type:`message_meta`,stopReason:e}}function*n(n,r){n.usage&&(yield{type:`message_meta`,inputTokens:n.usage.prompt_tokens,outputTokens:n.usage.completion_tokens,stopReason:``});let i=n.choices?.[0];if(!i)return;let a=i.delta;if(a){if(a.content&&(yield{type:`text_delta`,text:a.content}),a.tool_calls)for(let t of a.tool_calls)yield*e(t,r);i.finish_reason&&(yield*t(i.finish_reason,r))}}var r=class{client;apiKey;baseURL;initialized=!1;constructor(e,t){this.apiKey=e,this.baseURL=t?.baseURL}async ensureClient(){if(this.initialized)return;let e;try{let t=await Promise.resolve().then(()=>require("./openai-D0musiYP.cjs"));e=t.default||t.OpenAI||t}catch{throw Error(`openai is required for the OpenAI provider. Install it with: npm install openai`)}let t={apiKey:this.apiKey};this.baseURL&&(t.baseURL=this.baseURL),this.client=new e(t),this.initialized=!0}async createStream(e){await this.ensureClient();let{messages:t}=this.formatMessages(e.messages,e.system);return this.client.chat.completions.create({model:e.model,max_completion_tokens:e.maxTokens,tools:this.formatTools(e.tools),messages:t,stream:!0,stream_options:{include_usage:!0}})}async*parseStreamEvents(e){let t=new Map;for await(let r of e)yield*n(r,t)}formatTools(e){return e.map(e=>({type:`function`,function:{name:e.name,description:e.description,parameters:e.parameters}}))}formatMessages(e,t){let n=[{role:`system`,content:t}];for(let t of e)if(t.role===`user`)n.push({role:`user`,content:typeof t.content==`string`?t.content:JSON.stringify(t.content)});else if(t.role===`assistant`)if(typeof t.content==`string`)n.push({role:`assistant`,content:t.content});else{let e=t.content,r=e.filter(e=>e.type===`text`).map(e=>e.text).join(``),i=e.filter(e=>e.type===`tool_use`).map(e=>({id:e.id,type:`function`,function:{name:e.name,arguments:JSON.stringify(e.input||{})}})),a={role:`assistant`};r&&(a.content=r),i.length>0&&(a.tool_calls=i),n.push(a)}else t.role===`tool`?n.push(t):t.role===`tool_result`&&n.push({role:`user`,content:typeof t.content==`string`?t.content:JSON.stringify(t.content)});return{messages:n}}formatToolResults(e){return e.map(e=>({role:`tool`,tool_call_id:e.toolUseId,content:e.content}))}shouldContinue(e){return e===`tool_calls`}formatError(e){if(!e||!(e instanceof Error))return`Something went wrong. Please try again.`;let t=e.message||``,n=e;return n.status===429?`Too many requests. Please wait a moment and try again.`:n.status===401?`Authentication failed. Please check your API key configuration.`:n.status===503||n.status===502?`The AI service is temporarily unavailable. Please try again in a moment.`:n.status===400?`There was a problem with the request. Please try again.`:t.startsWith(`{`)||t.startsWith(`Error: {`)?`The AI service encountered an error. Please try again.`:t}};exports.OpenAIProvider=r;