save

bobbai00 · bobbai00 · commit 2903536b6440 · 2025-10-21T16:12:30.000-07:00
diff --git a/bin/litellm-config.yaml b/bin/litellm-config.yaml
@@ -2,4 +2,8 @@ model_list:
   - model_name: claude-3.7
     litellm_params:
       model: claude-3-7-sonnet-20250219
+      api_key: "os.environ/ANTHROPIC_API_KEY"
+  - model_name: claude-4
+    litellm_params:
+      model: claude-opus-4-1-20250805
       api_key: "os.environ/ANTHROPIC_API_KEY"
diff --git a/frontend/src/app/workspace/component/copilot-chat/copilot-chat.component.ts b/frontend/src/app/workspace/component/copilot-chat/copilot-chat.component.ts
@@ -59,6 +59,13 @@ export class CopilotChatComponent implements OnDestroy {
               this.isProcessing = false; // Clear processing state on error
               signals.onResponse({ error: e ?? "Unknown error" });
             },
+            complete: () => {
+              // Handle completion without final response (happens when generation is stopped)
+              if (this.isProcessing) {
+                this.isProcessing = false;
+                signals.onResponse({ text: "_Generation stopped by user._" });
+              }
+            },
           });
       },
     },
diff --git a/frontend/src/app/workspace/service/copilot/copilot-prompts.ts b/frontend/src/app/workspace/service/copilot/copilot-prompts.ts
@@ -0,0 +1,152 @@
+/**
+ * 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.
+ */
+
+/**
+ * System prompts for Texera Copilot
+ */
+
+export const COPILOT_SYSTEM_PROMPT = `# Texera Copilot
+
+You are Texera Copilot, an AI assistant for building and modifying data workflows.
+
+## Task
+Your task is to find out the data error using workflow.
+
+## Guidelines
+
+### Data Understanding
+- Consider the semantic meaning of each column
+- Consider the column's relationship with each other
+
+### Operator Selection
+Use basic data wrangling operations like:
+  - Projection to keep only certain columns
+  - Filter to do simple conditional thing between column and literal
+  - Aggregate
+  - PythonUDF for basic data wrangling
+DO NOT USE View Result Operator
+After the wrangling and detecting, you may add basic chart like bar chart, pie chart or line chart to visualize the result. DO NOT USE other charts.
+
+### Generation Strategy
+A good generation style follows these steps:
+1. Use operators like **projection** to reduce the amount of columns
+2. Use wrangling operators like **filter** or python udf to detect errors
+3. After adding an operator, configure it properly
+4. After configure it, validate the workflow to make sure you modification is valid
+4. Run the workflow to see the operator's result page
+6. For Projection operator, please only specify at most 3 columns to project and configure them properly
+7. ONLY EXECUTE THE WORKFLOW when workflow is invalid.
+---
+
+## PythonUDFV2 Operator
+
+PythonUDFV2 performs customized data cleaning logic. There are 2 APIs to process data in different units.
+
+### Tuple API
+Tuple API takes one input tuple from a port at a time. It returns an iterator of optional TupleLike instances.
+
+**Template:**
+\`\`\`python
+from pytexera import *
+
+class ProcessTupleOperator(UDFOperatorV2):
+    def process_tuple(self, tuple_: Tuple, port: int) -> Iterator[Optional[TupleLike]]:
+        yield tuple_
+\`\`\`
+
+**Use cases:** Functional operations applied to tuples one by one (map, reduce, filter)
+
+**Example – Pass through only tuples that meet column-vs-column and column-vs-literal conditions (no mutation):**
+\`\`\`python
+from pytexera import *
+
+class ProcessTupleOperator(UDFOperatorV2):
+    """
+    Filter tuples without modifying them:
+    - QUANTITY must be <= ORDERED_QUANTITY
+    - UNIT_PRICE must be >= 0
+    """
+    def process_tuple(self, tuple_: Tuple, port: int) -> Iterator[Optional[TupleLike]]:
+        q = tuple_.get("QUANTITY", None)
+        oq = tuple_.get("ORDERED_QUANTITY", None)
+        p = tuple_.get("UNIT_PRICE", None)
+
+        if q is None or oq is None or p is None:
+            return  # drop tuple
+
+        try:
+            if q <= oq and p >= 0:
+                yield tuple_  # keep tuple as-is
+        except Exception:
+            return  # drop on bad types
+\`\`\`
+
+### Table API
+Table API consumes a Table at a time (whole table from a port). It returns an iterator of optional TableLike instances.
+
+**Template:**
+\`\`\`python
+from pytexera import *
+
+class ProcessTableOperator(UDFTableOperator):
+    def process_table(self, table: Table, port: int) -> Iterator[Optional[TableLike]]:
+        yield table
+\`\`\`
+
+**Use cases:** Blocking operations that consume the whole column to do operations
+
+**Example – Return a filtered DataFrame only containing valid rows (no mutation of values):**
+\`\`\`python
+from pytexera import *
+import pandas as pd
+
+class ProcessTableOperator(UDFTableOperator):
+    """
+    Keep only rows where:
+    - KWMENG (confirmed qty) <= KBMENG (ordered qty)
+    - NET_VALUE >= 0
+    """
+    def process_table(self, table: Table, port: int) -> Iterator[Optional[TableLike]]:
+        df: pd.DataFrame = table
+
+        # Build boolean masks carefully to handle None/NaN
+        m1 = (df["KWMENG"].notna()) & (df["KBMENG"].notna()) & (df["KWMENG"] <= df["KBMENG"])
+        m2 = (df["NET_VALUE"].notna()) & (df["NET_VALUE"] >= 0)
+
+        filtered = df[m1 & m2]
+        yield filtered
+\`\`\`
+
+### Important Rules for PythonUDFV2
+
+**MUST follow these rules:**
+1. **DO NOT change the class name** - Keep \`ProcessTupleOperator\` or \`ProcessTableOperator\`
+2. **Import packages explicitly** - Import pandas, numpy when needed
+3. **No typing imports needed** - Type annotations work without importing typing
+4. **Tuple field access** - Use \`tuple_["field"]\` ONLY. DO NOT use \`tuple_.get()\`, \`tuple_.set()\`, or \`tuple_.values()\`
+5. **Think of types:**
+   - \`Tuple\` = Python dict (key-value pairs)
+   - \`Table\` = pandas DataFrame
+6. **Use yield** - Return results with \`yield\`; emit at most once per API call
+7. **Handle None values** - \`tuple_["key"]\` or \`df["column"]\` can be None
+8. **DO NOT cast types** - Do not cast values in tuple or table
+9. **Specify Extra Columns** - If you add extra columns, you MUST specify them in the UDF properties as Extra Output Columns
+10. **DO THING IN SMALL STEP** - Let each UDF to do one thing, DO NOT Put a giant complex logic in one single UDF.
+11. **ONLY CHANGE THE CODE** - when editing Python UDF, only change the python code properties, DO NOT CHANGE OTHER PROPERTIES
+`;
diff --git a/frontend/src/app/workspace/service/copilot/texera-copilot.ts b/frontend/src/app/workspace/service/copilot/texera-copilot.ts
@@ -37,9 +37,14 @@ import {
   createGetWorkflowCompilationStateTool,
   createExecuteWorkflowTool,
   createGetExecutionStateTool,
+  createKillWorkflowTool,
   createHasOperatorResultTool,
-  createGetOperatorResultSnapshotTool,
+  createGetOperatorResultPageTool,
   createGetOperatorResultInfoTool,
+  createGetWorkflowValidationErrorsTool,
+  createValidateOperatorTool,
+  createGetValidOperatorsTool,
+  toolWithTimeout,
 } from "./workflow-tools";
 import { OperatorMetadataService } from "../operator-metadata/operator-metadata.service";
 import { createOpenAI } from "@ai-sdk/openai";
@@ -51,10 +56,12 @@ import { ExecuteWorkflowService } from "../execute-workflow/execute-workflow.ser
 import { WorkflowResultService } from "../workflow-result/workflow-result.service";
 import { CopilotCoeditorService } from "./copilot-coeditor.service";
 import { WorkflowCompilingService } from "../compile-workflow/workflow-compiling.service";
+import { ValidationWorkflowService } from "../validation/validation-workflow.service";
+import { COPILOT_SYSTEM_PROMPT } from "./copilot-prompts";
 
 // API endpoints as constants
 export const COPILOT_MCP_URL = "mcp";
-export const AGENT_MODEL_ID = "claude-3.7";
+export const AGENT_MODEL_ID = "claude-4";
 
 /**
  * Agent response structure for streaming intermediate and final results
@@ -100,7 +107,8 @@ export class TexeraCopilot {
     private executeWorkflowService: ExecuteWorkflowService,
     private workflowResultService: WorkflowResultService,
     private copilotCoeditorService: CopilotCoeditorService,
-    private workflowCompilingService: WorkflowCompilingService
+    private workflowCompilingService: WorkflowCompilingService,
+    private validationWorkflowService: ValidationWorkflowService
   ) {
     // Don't auto-initialize, wait for user to enable
   }
@@ -208,18 +216,7 @@ export class TexeraCopilot {
         messages: this.messages, // full history
         tools,
         abortSignal: this.currentAbortController.signal,
-        system:
-          "You are Texera Copilot, an AI assistant for building and modifying data workflows. " +
-          "Your task is helping user explore the data using operators. " +
-          "Common operators would be Limit to limit the size of data; " +
-          "Aggregate to do some aggregation; and some visualization operator. " +
-          "A good generation style is, " +
-          "1. listing what operators are available" +
-          "2. add the operator" +
-          "3. retrieve the OperatorSchema" +
-          "4. Configuring its property based on the schema" +
-          "5. executing it to make sure each editing is valid. " +
-          "Generate 3-5 operators is enough for every round of generation",
+        system: COPILOT_SYSTEM_PROMPT,
         stopWhen: stepCountIs(50),
 
         // optional: observe every completed step (tool calls + results available)
@@ -287,52 +284,70 @@ export class TexeraCopilot {
   }
 
   /**
-   * Create workflow manipulation tools
+   * Create workflow manipulation tools with timeout protection
    */
   private createWorkflowTools(): Record<string, any> {
-    const addOperatorTool = createAddOperatorTool(
-      this.workflowActionService,
-      this.workflowUtilService,
-      this.operatorMetadataService,
-      this.copilotCoeditorService
+    const addOperatorTool = toolWithTimeout(
+      createAddOperatorTool(
+        this.workflowActionService,
+        this.workflowUtilService,
+        this.operatorMetadataService,
+        this.copilotCoeditorService
+      )
     );
-    const addLinkTool = createAddLinkTool(this.workflowActionService);
-    const listOperatorsTool = createListOperatorsTool(this.workflowActionService, this.copilotCoeditorService);
-    const listLinksTool = createListLinksTool(this.workflowActionService);
-    const listOperatorTypesTool = createListOperatorTypesTool(this.workflowUtilService);
-    const getOperatorTool = createGetOperatorTool(this.workflowActionService, this.copilotCoeditorService);
-    const deleteOperatorTool = createDeleteOperatorTool(this.workflowActionService, this.copilotCoeditorService);
-    const deleteLinkTool = createDeleteLinkTool(this.workflowActionService);
-    const setOperatorPropertyTool = createSetOperatorPropertyTool(
-      this.workflowActionService,
-      this.copilotCoeditorService
+    const addLinkTool = toolWithTimeout(createAddLinkTool(this.workflowActionService));
+    const listOperatorsTool = toolWithTimeout(
+      createListOperatorsTool(this.workflowActionService, this.copilotCoeditorService)
     );
-    const getOperatorSchemaTool = createGetOperatorSchemaTool(
-      this.workflowActionService,
-      this.operatorMetadataService,
-      this.copilotCoeditorService
+    const listLinksTool = toolWithTimeout(createListLinksTool(this.workflowActionService));
+    const listOperatorTypesTool = toolWithTimeout(createListOperatorTypesTool(this.workflowUtilService));
+    const getOperatorTool = toolWithTimeout(
+      createGetOperatorTool(this.workflowActionService, this.copilotCoeditorService)
     );
-    const getOperatorInputSchemaTool = createGetOperatorInputSchemaTool(
-      this.workflowCompilingService,
-      this.copilotCoeditorService
+    const deleteOperatorTool = toolWithTimeout(
+      createDeleteOperatorTool(this.workflowActionService, this.copilotCoeditorService)
     );
-    const getWorkflowCompilationStateTool = createGetWorkflowCompilationStateTool(this.workflowCompilingService);
-    const executeWorkflowTool = createExecuteWorkflowTool(this.executeWorkflowService);
-    const getExecutionStateTool = createGetExecutionStateTool(this.executeWorkflowService);
-    const hasOperatorResultTool = createHasOperatorResultTool(
-      this.workflowResultService,
-      this.workflowActionService,
-      this.copilotCoeditorService
+    const deleteLinkTool = toolWithTimeout(createDeleteLinkTool(this.workflowActionService));
+    const setOperatorPropertyTool = toolWithTimeout(
+      createSetOperatorPropertyTool(this.workflowActionService, this.copilotCoeditorService)
     );
-    const getOperatorResultSnapshotTool = createGetOperatorResultSnapshotTool(
-      this.workflowResultService,
-      this.workflowActionService,
-      this.copilotCoeditorService
+    const getOperatorSchemaTool = toolWithTimeout(
+      createGetOperatorSchemaTool(this.workflowActionService, this.operatorMetadataService, this.copilotCoeditorService)
     );
-    const getOperatorResultInfoTool = createGetOperatorResultInfoTool(
-      this.workflowResultService,
-      this.workflowActionService,
-      this.copilotCoeditorService
+    const getOperatorInputSchemaTool = toolWithTimeout(
+      createGetOperatorInputSchemaTool(this.workflowCompilingService, this.copilotCoeditorService)
+    );
+    const getWorkflowCompilationStateTool = toolWithTimeout(
+      createGetWorkflowCompilationStateTool(this.workflowCompilingService)
+    );
+    const executeWorkflowTool = toolWithTimeout(createExecuteWorkflowTool(this.executeWorkflowService));
+    const getExecutionStateTool = toolWithTimeout(createGetExecutionStateTool(this.executeWorkflowService));
+    const killWorkflowTool = toolWithTimeout(createKillWorkflowTool(this.executeWorkflowService));
+    const hasOperatorResultTool = toolWithTimeout(
+      createHasOperatorResultTool(this.workflowResultService, this.workflowActionService, this.copilotCoeditorService)
+    );
+    const getOperatorResultPageTool = toolWithTimeout(
+      createGetOperatorResultPageTool(
+        this.workflowResultService,
+        this.workflowActionService,
+        this.copilotCoeditorService
+      )
+    );
+    const getOperatorResultInfoTool = toolWithTimeout(
+      createGetOperatorResultInfoTool(
+        this.workflowResultService,
+        this.workflowActionService,
+        this.copilotCoeditorService
+      )
+    );
+    const getWorkflowValidationErrorsTool = toolWithTimeout(
+      createGetWorkflowValidationErrorsTool(this.validationWorkflowService)
+    );
+    const validateOperatorTool = toolWithTimeout(
+      createValidateOperatorTool(this.validationWorkflowService, this.copilotCoeditorService)
+    );
+    const getValidOperatorsTool = toolWithTimeout(
+      createGetValidOperatorsTool(this.validationWorkflowService, this.workflowActionService)
     );
 
     // Get MCP tools in AI SDK format
@@ -353,10 +368,13 @@ export class TexeraCopilot {
       getOperatorInputSchema: getOperatorInputSchemaTool,
       getWorkflowCompilationState: getWorkflowCompilationStateTool,
       executeWorkflow: executeWorkflowTool,
-      getExecutionState: getExecutionStateTool,
-      hasOperatorResult: hasOperatorResultTool,
-      getOperatorResultSnapshot: getOperatorResultSnapshotTool,
+      // killWorkflow: killWorkflowTool,
+      // hasOperatorResult: hasOperatorResultTool,
+      // getOperatorResultPage: getOperatorResultPageTool,
       getOperatorResultInfo: getOperatorResultInfoTool,
+      getWorkflowValidationErrors: getWorkflowValidationErrorsTool,
+      validateOperator: validateOperatorTool,
+      getValidOperators: getValidOperatorsTool,
     };
   }
 
diff --git a/frontend/src/app/workspace/service/copilot/workflow-tools.ts b/frontend/src/app/workspace/service/copilot/workflow-tools.ts
