From 5bff900bc4f439f20051bf2274ab2e485aad8008 Mon Sep 17 00:00:00 2001 From: xiaoyan-bot Date: Fri, 3 Apr 2026 16:32:05 +0800 Subject: [PATCH] auto-sync: task-router 2026-04-03_16:32 --- SKILL.md | 54 ++++++ agents/openai.yaml | 4 + component_configs.yaml | 74 ++++++++ scripts/generate_component.py | 61 +++++++ scripts/review_component.py | 67 ++++++++ scripts/route_request.py | 314 ++++++++++++++++++++++++++++++++++ test_config.json | 15 ++ 7 files changed, 589 insertions(+) create mode 100644 SKILL.md create mode 100644 agents/openai.yaml create mode 100644 component_configs.yaml create mode 100644 scripts/generate_component.py create mode 100644 scripts/review_component.py create mode 100755 scripts/route_request.py create mode 100644 test_config.json diff --git a/SKILL.md b/SKILL.md new file mode 100644 index 0000000..41ced90 --- /dev/null +++ b/SKILL.md @@ -0,0 +1,54 @@ +--- +name: dialogue-components-standardizer +description: A unified skill for standardizing the production and review of 6 dialogue interaction components. Core logic is fixed; optimizations are handled via branch files and scripts for repeatability. Enter skill only when components change dynamically. +--- + +# Dialogue Components Standardizer + +## Overview + +This skill provides a modular structure for standardizing dialogue components: +- **Core (Fixed)**: Component types, workflows, and policies (defined here). +- **Branch Files**: `component_configs.yaml` for component-specific details (modify for optimizations). +- **Scripts**: Automated execution for repeatable tasks (e.g., generation, review). +- **Dynamic Entry**: Use skill for component changes; otherwise, rely on scripts. + +## Core Structure + +### Component Types (Fixed) +The 6 components are predefined: +1. dialogue_reading +2. dialogue_expression +3. dialogue_selective_reading +4. dialogue_selection +5. dialogue_sentence_building +6. dialogue_fill_in_the_blanks + +### Workflows (Fixed) +- **Production**: Generate configs via script. +- **Review**: Validate via script. +- **Optimization**: Update `component_configs.yaml` for details. + +## Branch Files +- `component_configs.yaml`: Contains format, config, and validation rules per component. Modify this for optimizations without altering core. + +## Scripts +- `scripts/generate_component.py`: Generates component configs (repeatable). +- `scripts/review_component.py`: Reviews and validates configs (repeatable). + +## Usage +1. For standard production: Run scripts directly. +2. For component changes: Enter skill to update core or branch files. +3. Optimize details: Edit `component_configs.yaml`. + +## Examples +- Generate: `python3 scripts/generate_component.py --type dialogue_reading --output config.json` +- Review: `python3 scripts/review_component.py --file config.json` +- "Rewrite this paragraph to sound more professional." + Route: `low_compute_model` +- "Design the data-cleaning approach, then process the CSV." + Route: `high_compute_model`, then `python_script` + +## Resources + +- Use [route_request.py](/Users/shasha/.codex/skills/task-router/scripts/route_request.py) as the first-pass classifier and execution planner. diff --git a/agents/openai.yaml b/agents/openai.yaml new file mode 100644 index 0000000..52c9965 --- /dev/null +++ b/agents/openai.yaml @@ -0,0 +1,4 @@ +interface: + display_name: "Task Router" + short_description: "Route requests by execution cost" + default_prompt: "Use $task-router to decide whether a request should run a Python script, a high-compute model, or a low-compute model." diff --git a/component_configs.yaml b/component_configs.yaml new file mode 100644 index 0000000..f9392ee --- /dev/null +++ b/component_configs.yaml @@ -0,0 +1,74 @@ +# Component Configurations +# This file contains detailed configurations for each dialogue component. +# Modify this file for component-specific optimizations without changing the core skill. + +components: + dialogue_reading: + required_fields: ["text", "language"] + format: + text: "string" # Required + audio: "optional_file" # Optional + language: "string" # Required + config: + duration: 30 # Expected reading time in seconds + scoring_threshold: 80 # Accuracy threshold (0-100) + validation_rules: + - "text must not be empty" + - "language must be supported" + + dialogue_expression: + format: + text: "string_with_cues" # e.g., "[happy] Hello!" + media: "optional_file" # Video/image examples + config: + expression_types: ["happy", "sad", "angry"] + detection_threshold: 0.7 + validation_rules: + - "expression cues must match types" + - "media file must be valid" + + dialogue_selective_reading: + format: + full_dialogue: "string" + selectable_parts: "array_of_strings" + config: + min_selections: 1 + max_selections: 5 + feedback_enabled: true + validation_rules: + - "selectable_parts must be subset of full_dialogue" + - "selections count within limits" + + dialogue_selection: + format: + prompt: "string" + options: "array_of_strings" + correct_answer: "integer" # Index of correct option + config: + multiple_choice: false + points_per_correct: 1 + validation_rules: + - "correct_answer must be valid index" + - "options must have at least 2 items" + + dialogue_sentence_building: + format: + words_phrases: "array_of_strings" # Shuffled components + target_sentence: "string" + config: + difficulty_level: "medium" # "easy", "medium", "hard" + hints_enabled: true + validation_rules: + - "words_phrases must form target_sentence" + - "difficulty must be valid" + + dialogue_fill_in_the_blanks: + format: + template: "string_with_blanks" # e.g., "Hello [blank]!" + answers: "array_of_strings" + config: + case_sensitive: false + partial_credit: true + validation_rules: + - "blanks count must match answers" + - "template must have placeholders" \ No newline at end of file diff --git a/scripts/generate_component.py b/scripts/generate_component.py new file mode 100644 index 0000000..b13ee47 --- /dev/null +++ b/scripts/generate_component.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python3 +""" +generate_component.py +Script to generate standardized configurations for dialogue components. +Loads from component_configs.yaml and produces JSON output. +""" + +import argparse +import json +import yaml +import sys +import os + +CONFIG_FILE = os.path.join(os.path.dirname(__file__), '..', 'component_configs.yaml') + +def load_configs(): + with open(CONFIG_FILE, 'r', encoding='utf-8') as f: + return yaml.safe_load(f) + +def generate_component(component_type, **kwargs): + configs = load_configs() + if component_type not in configs['components']: + raise ValueError(f"Unknown component type: {component_type}") + + component_config = configs['components'][component_type] + # Merge provided kwargs with defaults + config = {**component_config['config'], **kwargs} + + output = { + "component_type": component_type, + "format": component_config['format'], + "config": config, + "status": "generated" + } + return output + +def main(): + parser = argparse.ArgumentParser(description="Generate dialogue component configuration.") + parser.add_argument('--type', required=True, help="Component type (e.g., dialogue_reading)") + parser.add_argument('--output', default='component.json', help="Output file") + # Add dynamic args based on config, but for simplicity, use kwargs + args, unknown = parser.parse_known_args() + + # Parse additional kwargs + kwargs = {} + for arg in unknown: + if '=' in arg: + key, value = arg.split('=', 1) + kwargs[key] = value + + try: + result = generate_component(args.type, **kwargs) + with open(args.output, 'w', encoding='utf-8') as f: + json.dump(result, f, indent=2, ensure_ascii=False) + print(f"Generated component config saved to {args.output}") + except Exception as e: + print(f"Error: {e}", file=sys.stderr) + sys.exit(1) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/review_component.py b/scripts/review_component.py new file mode 100644 index 0000000..2f49415 --- /dev/null +++ b/scripts/review_component.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +""" +review_component.py +Script to review and validate dialogue component configurations. +Loads from component_configs.yaml and checks against rules. +""" + +import argparse +import json +import yaml +import sys +import os + +CONFIG_FILE = os.path.join(os.path.dirname(__file__), '..', 'component_configs.yaml') + +def load_configs(): + with open(CONFIG_FILE, 'r', encoding='utf-8') as f: + return yaml.safe_load(f) + +def validate_component(component_data): + component_type = component_data.get('component_type') + configs = load_configs() + if component_type not in configs['components']: + return {"status": "error", "issues": [f"Unknown component type: {component_type}"]} + + component_config = configs['components'][component_type] + issues = [] + config_data = component_data.get('config', {}) + + # Check required fields + required_fields = component_config.get('required_fields', list(component_config['format'].keys())) + for field in required_fields: + if field not in config_data or not config_data[field]: + issues.append(f"Missing or empty required field: {field}") + + # Check validation rules (simplified) + for rule in component_config['validation_rules']: + if "must not be empty" in rule: + for field in component_config['format']: + if field in config_data and not config_data[field]: + issues.append(f"Field {field} {rule}") + + status = "approved" if not issues else "needs_fix" + return {"component_type": component_type, "issues": issues, "status": status} + +def main(): + parser = argparse.ArgumentParser(description="Review dialogue component configuration.") + parser.add_argument('--file', required=True, help="Component JSON file to review") + parser.add_argument('--strict', action='store_true', help="Fail on any issues") + + args = parser.parse_args() + + try: + with open(args.file, 'r', encoding='utf-8') as f: + component_data = json.load(f) + + result = validate_component(component_data) + print(json.dumps(result, indent=2, ensure_ascii=False)) + + if args.strict and result['status'] != 'approved': + sys.exit(1) + except Exception as e: + print(f"Error: {e}", file=sys.stderr) + sys.exit(1) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/route_request.py b/scripts/route_request.py new file mode 100755 index 0000000..f924d69 --- /dev/null +++ b/scripts/route_request.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +import argparse +import json +import re +import sys +from dataclasses import dataclass +from typing import Dict, List + + +ROUTES = ("python_script", "high_compute_model", "low_compute_model") + + +@dataclass +class RouteScore: + name: str + score: int + reasons: List[str] + + +def build_execution_plan(route: str, text: str, confidence: float) -> Dict[str, object]: + preview = " ".join(text.strip().split()) + if len(preview) > 140: + preview = preview[:137] + "..." + + if route == "python_script": + return { + "execution_type": "run_python", + "goal": "Handle the request with deterministic code execution.", + "immediate_action": "Inspect the files/data involved, then write or run a focused Python script.", + "codex_instruction": "Execute the task with Python first. Use the model only to design the script or explain the result.", + "artifacts_to_produce": [ + "a Python script or one-off Python command", + "structured output or generated files", + "a concise summary of what was processed", + ], + "escalate_if": [ + "the script needs significant algorithm or architecture design", + "requirements are ambiguous before coding can start", + ], + "request_preview": preview, + } + + if route == "high_compute_model": + return { + "execution_type": "run_high_compute_model", + "goal": "Handle the request with deeper reasoning before taking action.", + "immediate_action": "Use a stronger model to analyze the task, resolve ambiguity, and produce the answer or plan.", + "codex_instruction": "Give the task to a stronger model path first. If execution is later needed, convert the resulting plan into code or commands.", + "artifacts_to_produce": [ + "a detailed answer, design, or plan", + "explicit tradeoffs, assumptions, or decision criteria", + ], + "escalate_if": [ + "the task becomes procedural after planning", + "the answer requires file processing or repeatable transformations", + ], + "request_preview": preview, + } + + return { + "execution_type": "run_low_compute_model", + "goal": "Handle the request with the cheapest viable language-model pass.", + "immediate_action": "Use a lightweight model path for a fast first answer.", + "codex_instruction": "Start with a cheaper/faster model. Escalate only if the output is weak, incomplete, or the task expands.", + "artifacts_to_produce": [ + "a short answer or rewrite", + "minimal reasoning with quick turnaround", + ], + "escalate_if": [ + "the request turns out to be ambiguous", + "the first pass fails quality checks", + "multiple retries would cost more than escalating once", + ], + "request_preview": preview, + } + + +def normalize(text: str) -> str: + text = text.strip().lower() + text = re.sub(r"\s+", " ", text) + return text + + +def keyword_hits(text: str, keywords: List[str]) -> List[str]: + hits = [] + for keyword in keywords: + if keyword in text: + hits.append(keyword) + return hits + + +def score_python_route(text: str) -> RouteScore: + reasons: List[str] = [] + score = 0 + + deterministic_hits = keyword_hits( + text, + [ + "python", + "script", + "csv", + "json", + "yaml", + "xml", + "excel", + "spreadsheet", + "parse", + "extract", + "transform", + "convert", + "rename", + "batch", + "directory", + "folder", + "file", + "files", + "dataset", + "log", + "logs", + "calculate", + "count", + "sort", + "filter", + "regex", + "scrape", + ], + ) + if deterministic_hits: + score += 4 + min(len(deterministic_hits), 6) + reasons.append( + "deterministic data/file-processing signals: " + + ", ".join(deterministic_hits[:6]) + ) + + if any(token in text for token in ["automate", "repeatedly", "pipeline", "generate report"]): + score += 3 + reasons.append("request looks repetitive or automation-friendly") + + if any(token in text for token in ["exact", "precise", "reproducible", "structured output"]): + score += 2 + reasons.append("request favors reproducible execution over free-form reasoning") + + return RouteScore("python_script", score, reasons) + + +def score_high_route(text: str) -> RouteScore: + reasons: List[str] = [] + score = 0 + + reasoning_hits = keyword_hits( + text, + [ + "analyze", + "analysis", + "design", + "architect", + "strategy", + "compare", + "tradeoff", + "debug", + "root cause", + "plan", + "complex", + "hard", + "unclear", + "ambiguous", + "research", + "brainstorm", + "proposal", + "spec", + ], + ) + if reasoning_hits: + score += 4 + min(len(reasoning_hits), 6) + reasons.append( + "open-ended reasoning signals: " + ", ".join(reasoning_hits[:6]) + ) + + if any( + token in text + for token in ["step by step", "carefully", "deeply", "thoroughly", "rigorous"] + ): + score += 3 + reasons.append("user explicitly asks for deeper or more careful reasoning") + + if len(text.split()) > 80: + score += 2 + reasons.append("request is long enough to suggest higher-context reasoning") + + return RouteScore("high_compute_model", score, reasons) + + +def score_low_route(text: str) -> RouteScore: + reasons: List[str] = [] + score = 0 + + lightweight_hits = keyword_hits( + text, + [ + "rewrite", + "rephrase", + "translate", + "summarize", + "summary", + "classify", + "tag", + "format", + "clean up", + "fix grammar", + "short answer", + "quick", + "simple", + ], + ) + if lightweight_hits: + score += 4 + min(len(lightweight_hits), 5) + reasons.append( + "lightweight language-task signals: " + ", ".join(lightweight_hits[:6]) + ) + + if len(text.split()) <= 25: + score += 2 + reasons.append("request is short and likely cheap to answer") + + if any(token in text for token in ["cheap", "fast", "brief"]): + score += 2 + reasons.append("user is optimizing for speed or lower cost") + + return RouteScore("low_compute_model", score, reasons) + + +def choose_route(text: str) -> Dict[str, object]: + normalized = normalize(text) + if not normalized: + execution_plan = build_execution_plan("low_compute_model", text, 0.25) + return { + "route": "low_compute_model", + "confidence": 0.25, + "reasons": ["empty request defaults to the lowest-cost model"], + "scores": {route: 0 for route in ROUTES}, + "execution_plan": execution_plan, + } + + scored_routes = [ + score_python_route(normalized), + score_high_route(normalized), + score_low_route(normalized), + ] + scored_routes.sort(key=lambda item: item.score, reverse=True) + + winner = scored_routes[0] + runner_up = scored_routes[1] + + if winner.score == 0: + winner = RouteScore( + "high_compute_model", + 1, + ["fallback to the stronger model because the task is not obviously deterministic or trivial"], + ) + runner_up = RouteScore("low_compute_model", 0, []) + + margin = max(winner.score - runner_up.score, 0) + confidence = min(0.55 + 0.1 * margin, 0.95) + + recommended_next_action = { + "python_script": "Prefer executing or writing a Python script first, then use a model only for glue logic or explanation.", + "high_compute_model": "Prefer a stronger model for planning, ambiguity resolution, or multi-step reasoning.", + "low_compute_model": "Prefer a cheaper/faster model for the first pass and escalate only if it struggles.", + }[winner.name] + confidence = round(confidence, 2) + execution_plan = build_execution_plan(winner.name, text, confidence) + + return { + "route": winner.name, + "confidence": confidence, + "reasons": winner.reasons, + "scores": {item.name: item.score for item in scored_routes}, + "recommended_next_action": recommended_next_action, + "execution_plan": execution_plan, + } + + +def main() -> int: + parser = argparse.ArgumentParser( + description="Route a request to python_script, high_compute_model, or low_compute_model." + ) + parser.add_argument("--text", help="Request text to classify. If omitted, read from stdin.") + parser.add_argument( + "--pretty", + action="store_true", + help="Pretty-print JSON output.", + ) + parser.add_argument( + "--summary", + action="store_true", + help="Print a compact human-readable routing summary instead of JSON.", + ) + args = parser.parse_args() + + text = args.text if args.text is not None else sys.stdin.read() + result = choose_route(text) + if args.summary: + print(f"Route: {result['route']}") + print("Why: " + "; ".join(result["reasons"][:2])) + print("Next step: " + result["execution_plan"]["immediate_action"]) + elif args.pretty: + print(json.dumps(result, indent=2, ensure_ascii=True)) + else: + print(json.dumps(result, ensure_ascii=True)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/test_config.json b/test_config.json new file mode 100644 index 0000000..44c70d8 --- /dev/null +++ b/test_config.json @@ -0,0 +1,15 @@ +{ + "component_type": "dialogue_reading", + "format": { + "text": "string", + "audio": "optional_file", + "language": "string" + }, + "config": { + "duration": 30, + "scoring_threshold": 80, + "text": "Hello, how are you?", + "language": "en" + }, + "status": "generated" +} \ No newline at end of file