# DSL-Leitfaden

## Andere Sprachen


---

Meistern Sie die Symbi DSL fuer den Aufbau richtlinienbewusster, sicherer KI-Agenten.

## Inhaltsverzeichnis


---

## Ueberblick

Die Symbi DSL ist eine domaenenspezifische Sprache, die fuer die Erstellung autonomer, richtlinienbewusster Agenten entwickelt wurde. Sie kombiniert traditionelle Programmierstrukturen mit erweiterten Sicherheitsfeatures, kryptographischen Operationen und deklarativen Richtliniendefinitionen.

### Hauptmerkmale

- **Sicherheitsorientiertes Design**: Eingebaute Richtliniendurchsetzung und Audit-Funktionen
- **Deklarative Richtlinien**: Sicherheitsanforderungen als Code ausdruecken
- **Kryptographische Operationen**: Native Unterstuetzung fuer Verschluesselung, Signierung und Beweise
- **Inter-Agent-Kommunikation**: Eingebaute Messaging- und Kollaborationsmuster
- **Typsicherheit**: Starke Typisierung mit sicherheitsbewussten Typannotationen

---

## Sprachsyntax

### Grundstruktur

Jedes Symbi-Programm besteht aus optionalen Metadaten und Agentendefinitionen:

```rust
metadata {
    version: "1.0.0"
    author: "developer"
    description: "Example agent"
}

agent process_data(input: DataSet) -> Result {
    // Agent implementation
}
```

> **Geplantes Feature** -- Import-Syntax ist fuer ein zukuenftiges Release geplant.
>
> ```rust
> import data_processing as dp;
> import security_utils;
> ```

### Kommentare

```rust
// Single-line comment
# Hash-style comment (also supported)

/*
 * Multi-line comment
 * Supports markdown formatting
 */
```

---

## Metadatenbloecke

Metadaten stellen wesentliche Informationen ueber Ihren Agenten bereit:

```rust
metadata {
    version: "1.2.0"
    author: "ThirdKey Security Team"
    description: "Healthcare data analysis agent with HIPAA compliance"
    license: "Proprietary"
    tags: ["healthcare", "hipaa", "analysis"]
}
```

Metadaten-Paare akzeptieren entweder `=` oder `:` als Trennzeichen.

### Metadatenfelder

| Feld | Typ | Erforderlich | Beschreibung |
|-------|------|----------|-------------|
| `version` | String | Ja | Semantische Version des Agenten |
| `author` | String | Ja | Agent-Autor oder Organisation |
| `description` | String | Ja | Kurze Beschreibung der Agent-Funktionalitaet |
| `license` | String | Nein | Lizenzidentifikator |
| `tags` | Array[String] | Nein | Klassifizierungs-Tags |

Verwaltete-CLI-Agenten (Modus B) erkennen diese zusaetzlichen Metadaten-Schluessel, die von `symbi run` gelesen werden, um einen kontrollierten Claude-Code-Subprozess zu starten (siehe `agents/code_reviewer.symbi`):

| Feld | Typ | Beschreibung |
|-------|------|-------------|
| `executor` | String | Auf `"claude_code"` setzen, um den Agenten als kontrollierten Claude-Code-Subprozess statt ueber die Reasoning-Schleife auszufuehren |
| `model` | String | Modell, das an den Subprozess uebergeben wird (z.B. `"claude-sonnet-4-5"`) |
| `allowed_tools` | String | Kommagetrennte Tool-Zulassungsliste fuer den Subprozess (z.B. `"Read,Grep,Glob"`) |
| `system_prompt` | String | Zusaetzlicher System-Prompt, der fuer den Subprozess angehaengt wird |

---

## Agentendefinitionen

### Grundlegende Agentenstruktur

```rust
agent agent_name(param1: Type1, param2: Type2) -> ReturnType {
    capabilities: [capability1, capability2]

    policy policy_name {
        // Policy rules
    }

    with configuration_options {
        // Agent implementation
    }
}
```

### Agentenparameter

Unterstuetzung fuer verschiedene Parametertypen:

```rust
agent complex_agent(
    // Basic types
    name: String,
    age: int,
    active: bool,

    // Optional parameters
    email: Optional<String>,

    // Complex types
    data: Array<Record>,
    config: Map<String, Value>,

    // Security-aware types
    sensitive_data: EncryptedData<PersonalInfo>,
    credentials: SecureString
) -> ProcessingResult {
    // Implementation
}
```

### Faehigkeitsdeklaration

Deklarieren Sie, was Ihr Agent kann:

```rust
agent data_processor(input: DataSet) -> Analysis {
    capabilities: [
        data_analysis,          // Core data processing
        statistical_modeling,   // Advanced analytics
        report_generation,      // Output formatting
        audit_logging           // Compliance tracking
    ]

    // Implementation
}
```

---

## Richtliniendefinitionen

Richtlinien definieren Sicherheits- und Compliance-Regeln, die zur Laufzeit durchgesetzt werden.

### Richtlinienstruktur

```rust
policy policy_name {
    allow: action_list if condition
    deny: action_list if condition
    require: requirement_list
    audit: audit_specification
}
```

### Zugriffskontrollrichtlinien

```rust
policy medical_data_access {
    allow: ["read", "analyze"] if user.role == "doctor"
    allow: ["read"] if user.role == "nurse"
    deny: ["export", "print"] if data.contains_pii == true
    require: [
        user.clearance >= "medical_professional",
        session.mfa_verified == true,
        audit_trail = true
    ]
}
```

### Datenklassifizierungsrichtlinien

```rust
policy data_classification {
    allow: process(data) if data.anonymized == true
    deny: store(data) if data.classification == "restricted"
    audit: all_operations with digital_signature
}
```

### Komplexe Richtlinienlogik

```rust
policy dynamic_access_control {
    allow: read(resource) if (
        user.department == resource.owner_department ||
        user.role == "administrator" ||
        (user.role == "auditor" && current_time.business_hours)
    )

    deny: write(resource) if (
        resource.locked == true ||
        user.last_training < 30d ||
        system.maintenance_mode == true
    )

    require: approval("supervisor") for operations on sensitive_data
}
```

---

## Typsystem

### Primitive Typen

```rust
// Basic types
let name: String = "Alice";
let count: int = 42;
let rate: float = 3.14;
let active: bool = true;
```

### Sammlungstypen

```rust
// Arrays
let numbers: Array<int> = [1, 2, 3, 4, 5];
let names: Array<String> = ["Alice", "Bob", "Charlie"];

// Maps
let config: Map<String, String> = {
    "host": "localhost",
    "port": "8080",
    "ssl": "true"
};

// Sets
let unique_ids: Set<String> = {"id1", "id2", "id3"};
```

### Sicherheitsbewusste Typen

```rust
// Encrypted types
let secret: EncryptedString = encrypt("sensitive_data", key);
let secure_number: Encrypted<int> = encrypt(42, key);

// Private data with differential privacy
let private_data: PrivateData<float> = PrivateData::new(value, epsilon=1.0);

// Verifiable results with zero-knowledge proofs
let verified_result: VerifiableResult<Analysis> = VerifiableResult {
    value: analysis,
    proof: generate_proof(analysis),
    signature: sign(analysis)
};
```

### Benutzerdefinierte Typen

```rust
// Type aliases
type UserId = String;
type EncryptedPersonalInfo = EncryptedData<PersonalInfo>;
```

> **Geplantes Feature** -- `struct`- und `enum`-Definitionen sind fuer ein zukuenftiges Release geplant. Derzeit werden nur `type`-Aliase unterstuetzt.
>
> ```rust
> // Struct definitions (geplant)
> struct PersonalInfo {
>     name: String,
>     email: EncryptedString,
>     phone: Optional<String>,
>     birth_date: Date
> }
>
> // Enum definitions (geplant)
> enum SecurityLevel {
>     Public,
>     Internal,
>     Confidential,
>     Restricted
> }
> ```

---

## Ausfuehrungskontext

Konfigurieren Sie die Ausfuehrung Ihres Agenten mit der `with`-Klausel:

### Speicherverwaltung

```rust
agent persistent_agent(data: DataSet) -> Result {
    with memory = "persistent", storage = "encrypted" {
        // Agent state persists across sessions
        store_knowledge(data);
        return process_with_history(data);
    }
}

agent ephemeral_agent(query: String) -> Answer {
    with memory = "ephemeral", cleanup = "immediate" {
        // Agent state is discarded after execution
        return quick_answer(query);
    }
}
```

### Datenschutzeinstellungen

```rust
agent privacy_preserving_agent(sensitive_data: PersonalInfo) -> Statistics {
    with privacy = "differential", epsilon = 1.0 {
        // Add differential privacy noise
        let noisy_stats = compute_statistics(sensitive_data);
        return add_privacy_noise(noisy_stats, epsilon);
    }
}
```

### Sicherheitskonfiguration

```rust
agent high_security_agent(classified_data: ClassifiedInfo) -> Report {
    with
        security = "maximum",
        sandbox = "firecracker",
        encryption = "homomorphic",
        requires = "top_secret_clearance"
    {
        // High-security processing
        return process_classified(classified_data);
    }
}
```

---

## Eingebaute Funktionen

### Datenverarbeitung

```rust
// Validation functions
if (validate_input(data)) {
    // Process valid data
}

// Data transformation
let cleaned_data = sanitize(raw_data);
let normalized = normalize(cleaned_data);
```

### Kryptographische Operationen

```rust
// Encryption/Decryption
let encrypted = encrypt(plaintext, public_key);
let decrypted = decrypt(ciphertext, private_key);

// Digital signatures
let signature = sign(message, private_key);
let valid = verify(message, signature, public_key);

// Zero-knowledge proofs
let proof = prove(statement);
let verified = verify_proof(proof, public_statement);
```

### Audit und Protokollierung

```rust
// Audit logging
audit_log("operation_started", {
    "operation": "data_processing",
    "user": user.id,
    "timestamp": now()
});

// Security events
security_event("policy_violation", {
    "policy": "data_access",
    "user": user.id,
    "resource": resource.id
});
```

---

## Inter-Agent-Kommunikation

### Direktes Messaging

```rust
agent coordinator(task: Task) -> Result {
    with communication = "secure" {
        // Send task to specialized agent
        let result = agent security_analyzer.analyze(task);

        if (result.safe) {
            let processed = agent data_processor.process(task);
            return processed;
        } else {
            return reject("Security check failed");
        }
    }
}
```

### Publish-Subscribe-Muster

```rust
agent event_publisher(event: Event) -> Confirmation {
    with communication = "broadcast" {
        // Broadcast event to all subscribers
        broadcast(EventNotification {
            type: event.type,
            data: event.data,
            timestamp: now()
        });

        return Confirmation { sent: true };
    }
}

agent event_subscriber() -> Void {
    with communication = "subscribe" {
        // Subscribe to specific events
        let events = subscribe(EventNotification);

        for event in events {
            process_event(event);
        }
    }
}
```

### Sichere Kommunikation

```rust
agent secure_collaborator(request: SecureRequest) -> SecureResponse {
    with
        communication = "encrypted",
        authentication = "mutual_tls"
    {
        // Establish secure channel
        let channel = establish_secure_channel(request.source);

        // Send encrypted response
        let response = process_request(request);
        return encrypt_response(response, channel.key);
    }
}
```

---

## Fehlerbehandlung

### Try-Catch-Bloecke

```rust
agent robust_processor(data: DataSet) -> Result {
    try {
        let validated = validate_data(data);
        let processed = process_data(validated);
        return Ok(processed);
    } catch (ValidationError e) {
        audit_log("validation_failed", e.details);
        return Error("Invalid input data");
    } catch (ProcessingError e) {
        audit_log("processing_failed", e.details);
        return Error("Processing failed");
    }
}
```

### Fehlerwiederherstellung

```rust
agent fault_tolerant_agent(input: Input) -> Result {
    let max_retries = 3;
    let retry_count = 0;

    while (retry_count < max_retries) {
        try {
            return process_with_fallback(input);
        } catch (TransientError e) {
            retry_count += 1;
            sleep(exponential_backoff(retry_count));
        } catch (PermanentError e) {
            return Error(e.message);
        }
    }

    return Error("Max retries exceeded");
}
```

---

## Erweiterte Features

### Bedingte Kompilierung

> **Geplantes Feature** -- Bedingte Kompilierung ist fuer ein zukuenftiges Release geplant.

```rust
agent development_agent(data: DataSet) -> Result {
    capabilities: [development, testing]

    #if debug {
        debug_log("Processing data: " + data.summary);
    }

    #if feature.enhanced_security {
        policy strict_security {
            require: multi_factor_authentication
            audit: all_operations with timestamps
        }
    }

    // Implementation
}
```

### Makros und Codegenerierung

> **Geplantes Feature** -- Makrodefinitionen sind fuer ein zukuenftiges Release geplant.

```rust
// Define reusable policy template
macro secure_data_policy($classification: String) {
    policy secure_access {
        allow: read(data) if user.clearance >= $classification
        deny: export(data) if data.contains_pii
        audit: all_operations with signature
    }
}

agent classified_processor(data: ClassifiedData) -> Report {
    // Use the macro
    secure_data_policy!("secret");

    // Implementation
}
```

### Integration mit externen Systemen

```rust
agent api_integrator(request: APIRequest) -> APIResponse {
    capabilities: [api_access, data_transformation]

    policy api_access {
        allow: call(external_api) if api.rate_limit_ok
        require: valid_api_key
        audit: all_api_calls with response_codes
    }

    with
        timeout = 30.seconds,
        retry_policy = "exponential_backoff"
    {
        let response = call_external_api(request);
        return transform_response(response);
    }
}
```

---

## Best Practices

### Sicherheitsleitlinien

1. **Definieren Sie immer Richtlinien** fuer Datenzugriff und Operationen
2. **Verwenden Sie verschluesselte Typen** fuer sensible Daten
3. **Implementieren Sie Audit-Protokollierung** fuer Compliance
4. **Validieren Sie alle Eingaben** vor der Verarbeitung
5. **Verwenden Sie das Prinzip der minimalen Berechtigung** in Richtliniendefinitionen

### Leistungsoptimierung

1. **Verwenden Sie fluechtigen Speicher** fuer kurzlebige Agenten
2. **Buendeln Sie Operationen** wenn moeglich
3. **Implementieren Sie ordnungsgemaesse Fehlerbehandlung** mit Wiederholungen
4. **Ueberwachen Sie die Ressourcennutzung** im Ausfuehrungskontext
5. **Verwenden Sie geeignete Datentypen** fuer Ihren Anwendungsfall

### Code-Organisation

1. **Gruppieren Sie verwandte Richtlinien** im selben Block
2. **Verwenden Sie beschreibende Faehigkeitsnamen**
3. **Dokumentieren Sie komplexe Richtlinienlogik** mit Kommentaren
4. **Trennen Sie Anliegen** in verschiedene Agenten
5. **Verwenden Sie gemeinsame Muster wieder** mit gemeinsamen Richtliniendefinitionen

---

## Beispiele

### Gesundheitsdaten-Prozessor

```rust
metadata {
    version: "2.1.0"
    author: "Medical AI Team"
    description: "HIPAA-compliant patient data analyzer"
    tags: ["healthcare", "hipaa", "privacy"]
}

agent medical_analyzer(patient_data: EncryptedPatientRecord) -> MedicalInsights {
    capabilities: [
        medical_analysis,
        privacy_preservation,
        audit_logging,
        report_generation
    ]

    policy hipaa_compliance {
        allow: analyze(data) if user.medical_license.valid
        deny: export(data) if data.contains_identifiers
        require: [
            user.hipaa_training.completed,
            session.secure_connection,
            audit_trail = true
        ]
    }

    with
        memory = "encrypted",
        privacy = "differential",
        security = "high",
        requires = "medical_clearance"
    {
        try {
            let decrypted = decrypt(patient_data, medical_key);
            let anonymized = anonymize_data(decrypted);
            let insights = analyze_medical_data(anonymized);

            audit_log("analysis_completed", {
                "patient_id_hash": hash(decrypted.id),
                "insights_generated": insights.count,
                "timestamp": now()
            });

            return insights;
        } catch (DecryptionError e) {
            security_event("decryption_failed", e.details);
            return Error("Unable to process patient data");
        }
    }
}
```

### Finanz-Transaktionsmonitor

```rust
agent fraud_detector(transaction: Transaction) -> FraudAssessment {
    capabilities: [fraud_detection, risk_analysis, real_time_processing]

    policy financial_compliance {
        allow: analyze(transaction) if user.role == "fraud_analyst"
        deny: store(transaction.details) if transaction.amount > 10000
        require: [
            user.financial_license.valid,
            system.compliance_mode.active,
            real_time_monitoring = true
        ]
        audit: all_decisions with reasoning
    }

    with
        memory = "ephemeral",
        timeout = 500.milliseconds,
        priority = "high"
    {
        let risk_score = calculate_risk(transaction);
        let historical_pattern = analyze_pattern(transaction.account_id);

        if (risk_score > 0.8 || historical_pattern.suspicious) {
            alert_fraud_team(transaction, risk_score);
            return FraudAssessment {
                risk_level: "high",
                recommended_action: "block_transaction",
                confidence: risk_score
            };
        }

        return FraudAssessment {
            risk_level: "low",
            recommended_action: "approve",
            confidence: 1.0 - risk_score
        };
    }
}
```

---

## Naechste Schritte

- **[DSL-Spezifikation](dsl-specification.md)** - Vollstaendige Sprachspezifikationsreferenz
- **[Runtime-Architektur](/runtime-architecture)** - Verstehen Sie, wie Agenten ausgefuehrt werden
- **[Sicherheitsmodell](/security-model)** - Lernen Sie ueber die Sicherheitsimplementierung
- **[API-Referenz](/api-reference)** - Vollstaendige Funktions- und Typenreferenz
- **[Beispiele](https://github.com/thirdkeyai/symbiont/tree/main/examples)** - Weitere vollstaendige Beispiele

Bereit, Ihren ersten Agenten zu erstellen? Schauen Sie sich unseren [Startleitfaden](/getting-started) an oder erkunden Sie die [Runtime-Beispiele](https://github.com/thirdkeyai/symbiont/tree/main/crates/runtime/examples).
