gupta-sahil01 commented on code in PR #6437: URL: https://github.com/apache/texera/pull/6437#discussion_r3787428196
########## frontend/src/app/workspace/service/operator-recommendation/operator-recommendation.service.ts: ########## @@ -0,0 +1,166 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import { Injectable } from "@angular/core"; +import { HttpClient } from "@angular/common/http"; +import { Observable, catchError, map, of } from "rxjs"; +import { OperatorLink, OperatorPredicate, Point } from "../../types/workflow-common.interface"; +import { WorkflowActionService } from "../workflow-graph/model/workflow-action.service"; +import { WorkflowUtilService } from "../workflow-graph/util/workflow-util.service"; +import { JointUIService } from "../joint-ui/joint-ui.service"; +import { GuiConfigService } from "../../../common/service/gui-config.service"; + +/** + * A single operator suggestion returned by the agent-service `/api/recommend` + * endpoint (apache/texera#5240). Mirrors the backend `OperatorRecommendation`. + */ +export interface OperatorRecommendation { + /** Recommended operator type (validated against the live catalog when available). */ + operatorType: string; + /** Confidence in `[0, 1]`, monotonically non-increasing down the list. */ + score: number; + /** Short, human-readable rationale shown alongside the suggested operator. */ + reason: string; + /** Display name from operator metadata, when available. */ + userFriendlyName?: string; +} + +interface RecommendationResponse { + recommendations: OperatorRecommendation[]; + strategy: "hardcoded" | "llm"; +} + +/** + * Client for the ambient operator recommender. Asks the stateless agent-service + * endpoint what operators are likely to follow the one just added, and turns a + * chosen suggestion into a real operator wired onto the source's output port. + * + * The service never fails loudly: the recommender is a non-essential, ambient + * aid, so a backend error or a disabled feature simply yields no suggestions + * and the canvas behaves exactly as before. + */ +@Injectable({ + providedIn: "root", +}) +export class OperatorRecommendationService { + private static readonly RECOMMEND_API_URL = "/api/recommend"; + + // Horizontal gap between the source operator and a materialized suggestion. + private static readonly MATERIALIZE_GAP_X = 100; + + constructor( + private http: HttpClient, + private config: GuiConfigService, + private workflowActionService: WorkflowActionService, + private workflowUtilService: WorkflowUtilService + ) {} + + /** Whether the opt-in recommender feature is turned on for this deployment. */ + public isEnabled(): boolean { + return this.config.env.operatorRecommendationEnabled === true; + } + + /** + * Fetch ranked next-operator suggestions for the operator just added. + * + * Returns an empty list (never errors) when the feature is disabled, the + * operator has no output port to suggest from, or the backend call fails. + * + * How many suggestions come back is the backend's call: it defaults to three + * and clamps anything larger, so there is nothing useful to send from here. Review Comment: Done ########## frontend/src/app/workspace/service/drag-drop/drag-drop.service.ts: ########## @@ -75,10 +75,16 @@ export class DragDropService { this.workflowActionService.addOperatorsAndLinks([{ op: this.op, pos: coordinates }], newLinks); this.resetSuggestions(); - this.operatorDroppedSubject.next(); + this.operatorDroppedSubject.next(this.op); } - get operatorDropStream() { + /** + * Emits the operator a user just dropped onto the canvas, after it has been + * added to the graph. Unlike the graph's own operator-add stream, this fires + * only for interactive drag-drop placement — not for workflow load, undo/redo, + * paste, or a remote co-editor's edits. + */ + get operatorDropStream(): Observable<OperatorPredicate> { Review Comment: Added. expect(droppedOperator).toBe(newOp) — identity rather than toEqual, since a stale this.op would be a structurally similar predicate with a different ID and could slip past structural equality. Verified by mutating dragDropped to emit a fresh predicate of the same type: the test fails. ########## frontend/src/app/workspace/component/workflow-editor/workflow-editor.component.ts: ########## @@ -1717,6 +1764,205 @@ export class WorkflowEditorComponent implements OnInit, AfterViewInit, OnDestroy return this.operatorSummaries.get(operatorId)?.sampleRecords?.[0]?.["__is_visualization__"] === true; } + /** + * Ambient operator recommender (apache/texera#5240). When the user drops an + * operator onto the canvas, ask the recommender for likely next operators and + * float them as suggestion chips on the operator's output port; clicking one + * materializes it. The whole feature is opt-in and self-effacing: if it is + * disabled or the backend returns nothing, the canvas is untouched. + */ + private handleNextOperatorSuggestions(): void { + if (!this.operatorRecommendationService.isEnabled()) { + return; + } + + // Repositioning is throttled: change:position fires once per drag frame. + this.repositionNextOperatorSuggestion$ + .pipe(auditTime(100), untilDestroyed(this)) + .subscribe(() => this.repositionNextOperatorSuggestions()); + + // Every suggestion request — from a drop or from chaining after a click — + // goes through this one pipeline. switchMap unsubscribes the previous + // request, so a slow response can neither overwrite newer suggestions nor + // re-open the overlay after the user dismissed it; `null` means "cancel". + this.nextOperatorSuggestionRequest$ + .pipe( + switchMap(operator => + operator === null + ? of(null) + : this.operatorRecommendationService + .getRecommendations(operator) + .pipe(map(recommendations => ({ operator, recommendations }))) + ), + untilDestroyed(this) + ) + .subscribe(result => this.showNextOperatorSuggestions(result)); + + // Trigger: the user interactively dropped an operator onto the canvas. + // Deliberately not the graph's operator-add stream, which also fires on + // workflow load, undo/redo, paste, and remote co-editor edits — none of + // which are a user authoring a next step. + this.dragDropService.operatorDropStream + .pipe(untilDestroyed(this)) + .subscribe(operator => this.requestNextOperatorSuggestionsFor(operator)); + + // Dismiss when the user clicks on blank canvas. + fromJointPaperEvent(this.paper, "blank:pointerdown") + .pipe(untilDestroyed(this)) + .subscribe(() => this.closeNextOperatorSuggestions()); + + // Dismiss if the anchor operator is deleted out from under the suggestions. + this.workflowActionService + .getTexeraGraph() + .getOperatorDeleteStream() + .pipe(untilDestroyed(this)) + .subscribe(({ deletedOperatorID }) => { + if (this.nextOperatorSuggestion?.operatorId === deletedOperatorID) { + this.closeNextOperatorSuggestions(); + } + }); + + // Keep the suggestions anchored to the operator's output port as it moves. + this.paper.model.on("change:position", (cell: joint.dia.Cell) => { Review Comment: Fixed ours. There was a fromJointPaperEvent helper but no graph-model equivalent, so I added fromJointGraphCellEvent next to it and routed the listener through untilDestroyed(this) like its neighbours. Note it takes an explicit result selector — Backbone passes (cell, position, opt) and fromEventPattern would otherwise emit the arg array, which is why the paper helper is typed as Parameters<...>. Left 496 and 1673 alone since they predate this PR, but the helper is there for them — happy to convert both here if you'd rather it land together, or as a follow-up. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
