Protocol wire definitions

syntax = "proto3";

package akasha.daemon.v1;

option csharp_namespace = "Akasha.Daemon.V1";
option java_multiple_files = true;
option java_package = "ai.l1fe.akasha.daemon.v1";
option go_package = "akasha/daemon/v1";

message Empty {}

message CapabilityContext {
  string tenant_id = 1;
  string reservoir_id = 2;
  string agent_id = 3;
  string dataspace_id = 4;
  string namespace_hex = 5;
  repeated string actions = 6;
  repeated string keyspaces = 7;
  int64 expires_at_utc = 8;
}

message HealthResponse {
  string status = 1;
}

message SqlQueryRequest {
  string sql = 1;
  CapabilityContext capability = 99;
}

message SqlQueryResponse {
  repeated string rows_json = 1;
}

message CognitiveProcessEventRequest {
  string agent_id = 1;
  string event_type = 2;
  string payload_json = 3;
  CapabilityContext capability = 99;
}

message CognitiveProcessEventResponse {
  string result_json = 1;
}

message CognitiveMetricsRequest {
  CapabilityContext capability = 99;
}

message CognitiveMetricsResponse {
  string metrics_json = 1;
}

message CognitiveContextQueryRequest {
  string query = 1;
  CapabilityContext capability = 99;
}

message CognitiveContextQueryResponse {
  string context_json = 1;
}

message SupervisedSample {
  repeated float features = 1;
  uint32 label = 2;
}

message TrainingParams {
  optional uint32 epochs = 1;
  optional float learning_rate = 2;
  optional uint32 batch_size = 3;
  optional float weight_decay = 4;
}

message TrainSupervisedRequest {
  string model_name = 1;
  uint32 input_dim = 2;
  uint32 num_classes = 3;
  repeated SupervisedSample samples = 4;
  TrainingParams params = 5;
  CapabilityContext capability = 99;
}

message TrainSupervisedResponse {
  string model_id = 1;
  string status = 2;
  string model_name = 3;
  string model_version = 4;
  string metrics_json = 5;
}

message TrainHrmRequest {
  string domain = 1;
  string dataspace = 2;
  string primitive_keyspace = 3;
  string checkpoint_name = 4;
  string reservoir_id = 5;
  uint32 epochs = 6;
  uint32 batch_size = 7;
  string model_config_json = 8;
  string training_config_json = 9;
  repeated string inputs_json = 10 [deprecated = true];
  repeated string targets_json = 11 [deprecated = true];
  CapabilityContext capability = 99;
}

message TrainHrmResponse {
  string status = 1;
}

service AkashaDaemon {
  rpc Health(Empty) returns (HealthResponse);
  rpc SqlQuery(SqlQueryRequest) returns (SqlQueryResponse);
  rpc ProcessCognitiveEvent(CognitiveProcessEventRequest) returns (CognitiveProcessEventResponse);
  rpc GetCognitiveMetrics(CognitiveMetricsRequest) returns (CognitiveMetricsResponse);
  rpc QueryCognitiveContext(CognitiveContextQueryRequest) returns (CognitiveContextQueryResponse);
  rpc TrainSupervised(TrainSupervisedRequest) returns (TrainSupervisedResponse);
  rpc TrainHrm(TrainHrmRequest) returns (TrainHrmResponse);
}

syntax = "proto3";

package akasha.snn;

import "google/protobuf/timestamp.proto";

service SnnCoordination {
  rpc RegisterAgent (AgentRegistration) returns (RegistrationResponse);
  rpc SubmitWeightUpdates (WeightUpdateBatch) returns (UpdateResponse);
  rpc GetGlobalParameters (ParameterRequest) returns (GlobalParameters);
  rpc PropagateSpikeEvent (SpikeEvent) returns (PropagationResponse);
  rpc QueryCapabilities (CapabilityQuery) returns (CapabilityResponse);
}

message AgentRegistration {
  string agent_id = 1;
  string host = 2;
  repeated string capabilities = 3;
  repeated EnsembleInfo ensembles = 4;
  string visibility = 5;
  google.protobuf.Timestamp registered_at = 6;
}

message EnsembleInfo {
  string ensemble_id = 1;
  int32 n_neurons = 2;
  int32 dimensions = 3;
  repeated string specializations = 4;
}

message RegistrationResponse {
  string status = 1;
  string message = 2;
}

message WeightUpdateBatch {
  string agent_id = 1;
  repeated EnsembleWeightUpdate ensemble_updates = 2;
  repeated ConnectionWeightUpdate connection_updates = 3;
  google.protobuf.Timestamp timestamp = 4;
  float learning_rate = 5;
}

message EnsembleWeightUpdate {
  string ensemble_id = 1;
  repeated float weight_deltas = 2;
  repeated float bias_deltas = 3;
}

message ConnectionWeightUpdate {
  string connection_id = 1;
  repeated float weight_deltas = 2;
  string plasticity_rule = 3;
}

message UpdateResponse {
  string status = 1;
  int32 accepted_updates = 2;
  float global_contribution = 3;
}

message ParameterRequest {
  string agent_id = 1;
  repeated string ensemble_ids = 2;
  google.protobuf.Timestamp last_sync = 3;
}

message GlobalParameters {
  repeated EnsembleParameters ensemble_params = 1;
  repeated ConnectionParameters connection_params = 2;
  google.protobuf.Timestamp last_updated = 3;
  repeated string contributing_agents = 4;
}

message EnsembleParameters {
  string ensemble_id = 1;
  repeated float weights = 2;
  repeated float biases = 3;
  repeated float encoders = 4;
  float radius = 5;
}

message ConnectionParameters {
  string connection_id = 1;
  repeated float weights = 2;
  string plasticity_rule = 3;
  float learning_rate = 4;
}

message SpikeEvent {
  string source_agent_id = 1;
  string ensemble_id = 2;
  repeated int32 neuron_indices = 3;
  repeated float spike_times = 4;
  float intensity = 5;
  google.protobuf.Timestamp timestamp = 6;
  repeated string target_agents = 7;
}

message PropagationResponse {
  string status = 1;
  int32 propagated_to_agents = 2;
  repeated string failed_agents = 3;
}

message CapabilityQuery {
  repeated string required_capabilities = 1;
  repeated string ensemble_specializations = 2;
  string visibility_filter = 3;
  int32 max_results = 4;
}

message CapabilityResponse {
  repeated AgentCapability agents = 1;
}

message AgentCapability {
  string agent_id = 1;
  string host = 2;
  repeated string capabilities = 3;
  repeated EnsembleInfo ensembles = 4;
  float trust_score = 5;
  string visibility = 6;
}

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "memory_ids": {
                    "type": "array",
                    "items": { "type": "string" },
                    "description": "Specific memory IDs to forget"
                },
                "query": {
                    "type": "string",
                    "description": "Forget memories matching this query (requires confirm_bulk)"
                },
                "reason": {
                    "type": "string",
                    "description": "Why this memory is being forgotten (stored in audit log)"
                },
                "confirm_bulk": {
                    "type": "boolean",
                    "default": false,
                    "description": "Must be true to forget multiple memories at once"
                },
                "mode": {
                    "type": "string",
                    "enum": ["soft", "hard"],
                    "default": "soft",
                    "description": "Delete mode: soft (recoverable) or hard (permanent)"
                }
            },
            "required": ["reason"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "aspects": {
                    "type": "array",
                    "items": {
                        "type": "string",
                        "enum": ["stats", "topics", "timeline", "health", "quotas"]
                    },
                    "default": ["stats"],
                    "description": "Which aspects of memory state to analyze"
                },
                "include_examples": {
                    "type": "boolean",
                    "default": false,
                    "description": "Include example memory IDs in topic analysis"
                },
                "topic_focus": {
                    "type": "string",
                    "description": "Optional: focus analysis on a specific topic"
                }
            }
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "What to remember"
                },
                "filters": {
                    "type": "object",
                    "properties": {
                        "memory_types": {
                            "type": "array",
                            "items": { "type": "string", "enum": ["episodic", "semantic", "procedural"] }
                        },
                        "time_range": {
                            "type": "object",
                            "properties": {
                                "after": { "type": "string", "format": "date-time" },
                                "before": { "type": "string", "format": "date-time" }
                            }
                        },
                        "tags": { "type": "array", "items": { "type": "string" } },
                        "min_importance": { "type": "number", "minimum": 0, "maximum": 1 }
                    }
                },
                "limit": { "type": "integer", "default": 10, "minimum": 1, "maximum": 100 }
            },
            "required": ["query"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "topic": {
                    "type": "string",
                    "description": "Topic or area to reflect upon"
                },
                "analysis_types": {
                    "type": "array",
                    "items": {
                        "type": "string",
                        "enum": ["patterns", "contradictions", "gaps", "connections", "summary"]
                    },
                    "default": ["summary"]
                },
                "consolidate": {
                    "type": "boolean",
                    "default": false,
                    "description": "If true, create consolidated memories from episodic clusters"
                },
                "depth": {
                    "type": "string",
                    "enum": ["shallow", "moderate", "deep"],
                    "default": "moderate"
                }
            },
            "required": ["topic"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "content": {
                    "type": "string",
                    "description": "The memory content to store"
                },
                "context": {
                    "type": "object",
                    "description": "Optional context about when/where/why this memory was formed",
                    "properties": {
                        "source": {
                            "type": "string",
                            "description": "Where this memory came from (e.g., 'user_input', 'observation')"
                        },
                        "timestamp": {
                            "type": "string",
                            "format": "date-time",
                            "description": "When this memory was formed"
                        },
                        "importance": {
                            "type": "number",
                            "minimum": 0,
                            "maximum": 1,
                            "description": "Importance hint (0.0 to 1.0)"
                        },
                        "tags": {
                            "type": "array",
                            "items": { "type": "string" },
                            "description": "Tags for categorization"
                        }
                    }
                },
                "memory_type_hint": {
                    "type": "string",
                    "enum": ["auto", "episodic", "semantic", "procedural"],
                    "default": "auto",
                    "description": "Hint for memory classification (auto-detected if not specified)"
                }
            },
            "required": ["content"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "source_id": {
                    "type": "string",
                    "description": "ID of the source concept or memory"
                },
                "target_id": {
                    "type": "string",
                    "description": "ID of the target concept or memory"
                },
                "relationship": {
                    "type": "string",
                    "description": "Type of relationship (e.g., 'IS_A', 'PART_OF', 'RELATED_TO')"
                },
                "strength": {
                    "type": "number",
                    "minimum": 0,
                    "maximum": 1,
                    "default": 1.0,
                    "description": "Strength of the relationship (0.0 to 1.0)"
                },
                "bidirectional": {
                    "type": "boolean",
                    "default": false,
                    "description": "Whether to create a reverse link as well"
                },
                "metadata": {
                    "type": "object",
                    "additionalProperties": true,
                    "description": "Additional metadata for the edge"
                }
            },
            "required": ["source_id", "target_id", "relationship"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "procedure_id": {
                    "type": "string",
                    "description": "ID of the procedure to execute"
                },
                "procedure_name": {
                    "type": "string",
                    "description": "Name of the procedure to execute (alternative to ID)"
                },
                "parameters": {
                    "type": "object",
                    "additionalProperties": true,
                    "description": "Parameters to pass to the procedure"
                },
                "dry_run": {
                    "type": "boolean",
                    "default": false,
                    "description": "If true, describe what would happen without executing"
                }
            },
            "oneOf": [
                { "required": ["procedure_id"] },
                { "required": ["procedure_name"] }
            ]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "reference": {
                    "type": "string",
                    "description": "Text to find similar memories for"
                },
                "reference_memory_id": {
                    "type": "string",
                    "description": "ID of an existing memory to find similar ones"
                },
                "threshold": {
                    "type": "number",
                    "minimum": 0,
                    "maximum": 1,
                    "default": 0.7,
                    "description": "Minimum similarity score (0.0 to 1.0)"
                },
                "limit": {
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 100,
                    "default": 20,
                    "description": "Maximum number of results to return"
                }
            },
            "oneOf": [
                { "required": ["reference"] },
                { "required": ["reference_memory_id"] }
            ]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "time_expression": {
                    "type": "string",
                    "description": "Natural language time expression (e.g., 'last week', 'yesterday', 'in January 2024')"
                },
                "after": {
                    "type": "string",
                    "format": "date-time",
                    "description": "Only include memories after this time (ISO 8601)"
                },
                "before": {
                    "type": "string",
                    "format": "date-time",
                    "description": "Only include memories before this time (ISO 8601)"
                },
                "order": {
                    "type": "string",
                    "enum": ["chronological", "reverse_chronological", "relevance"],
                    "default": "reverse_chronological",
                    "description": "How to order results"
                },
                "limit": {
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 500,
                    "default": 50,
                    "description": "Maximum number of results"
                }
            },
            "anyOf": [
                { "required": ["time_expression"] },
                { "required": ["after"] },
                { "required": ["before"] }
            ]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "event": {
                    "type": "string",
                    "description": "Description of the event or experience"
                },
                "occurred_at": {
                    "type": "string",
                    "format": "date-time",
                    "description": "When this event occurred (ISO 8601 format). Defaults to now if not specified."
                },
                "participants": {
                    "type": "array",
                    "items": { "type": "string" },
                    "description": "Who was involved in this event"
                },
                "location": {
                    "type": "string",
                    "description": "Where the event happened"
                },
                "emotions": {
                    "type": "array",
                    "items": { "type": "string" },
                    "description": "Emotional associations with this event"
                },
                "importance": {
                    "type": "number",
                    "minimum": 0,
                    "maximum": 1,
                    "default": 0.5,
                    "description": "Importance score from 0.0 to 1.0"
                }
            },
            "required": ["event"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "subject": {
                    "type": "string",
                    "description": "What the fact is about (the entity or concept)"
                },
                "predicate": {
                    "type": "string",
                    "description": "The relationship or property (e.g., 'works_at', 'is_a', 'has_property')"
                },
                "object": {
                    "type": "string",
                    "description": "The value or related entity"
                },
                "confidence": {
                    "type": "number",
                    "minimum": 0,
                    "maximum": 1,
                    "default": 1.0,
                    "description": "Confidence level in this fact (0.0 to 1.0)"
                },
                "source": {
                    "type": "string",
                    "description": "Where this knowledge came from (for provenance)"
                },
                "valid_from": {
                    "type": "string",
                    "format": "date-time",
                    "description": "When this fact became/becomes valid (ISO 8601)"
                },
                "valid_until": {
                    "type": "string",
                    "format": "date-time",
                    "description": "When this fact ceases to be valid (ISO 8601)"
                }
            },
            "required": ["subject", "predicate", "object"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "name": {
                    "type": "string",
                    "description": "Name of the procedure"
                },
                "description": {
                    "type": "string",
                    "description": "What this procedure accomplishes"
                },
                "steps": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "order": {
                                "type": "integer",
                                "minimum": 1,
                                "description": "Step order (1-based)"
                            },
                            "action": {
                                "type": "string",
                                "description": "Action to perform in this step"
                            },
                            "conditions": {
                                "type": "string",
                                "description": "Optional condition for this step to execute"
                            },
                            "expected_outcome": {
                                "type": "string",
                                "description": "What should happen after this step completes"
                            }
                        },
                        "required": ["order", "action"]
                    },
                    "description": "Steps to perform, in order"
                },
                "triggers": {
                    "type": "array",
                    "items": { "type": "string" },
                    "description": "When to apply this procedure (e.g., 'database migration needed')"
                },
                "prerequisites": {
                    "type": "array",
                    "items": { "type": "string" },
                    "description": "Prerequisites that must be satisfied before execution"
                }
            },
            "required": ["name", "steps"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "items": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "content": {
                                "type": "string",
                                "description": "The memory content"
                            },
                            "memory_type": {
                                "type": "string",
                                "enum": ["episodic", "semantic", "procedural"],
                                "description": "Optional memory type classification"
                            },
                            "tags": {
                                "type": "array",
                                "items": { "type": "string" },
                                "description": "Optional tags for the memory"
                            },
                            "importance": {
                                "type": "number",
                                "minimum": 0,
                                "maximum": 1,
                                "description": "Optional importance score"
                            },
                            "metadata": {
                                "type": "object",
                                "description": "Optional metadata key-value pairs"
                            }
                        },
                        "required": ["content"]
                    },
                    "minItems": 1,
                    "maxItems": 10000,
                    "description": "Array of memory items to import"
                },
                "skip_duplicates": {
                    "type": "boolean",
                    "default": true,
                    "description": "Whether to skip duplicate items silently"
                },
                "source": {
                    "type": "string",
                    "description": "Source tag applied to all imported items"
                }
            },
            "required": ["items"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "index_type": {
                    "type": "string",
                    "enum": ["hnsw", "bm25", "hybrid"],
                    "description": "The type of index to configure"
                },
                "action": {
                    "type": "string",
                    "enum": ["get_config", "update", "rebuild", "stats"],
                    "description": "The action to perform"
                },
                "params": {
                    "type": "object",
                    "description": "Configuration parameters (varies by index_type and action)",
                    "properties": {
                        "m": {
                            "type": "integer",
                            "minimum": 4,
                            "maximum": 64,
                            "description": "HNSW: Number of connections per node"
                        },
                        "ef_construction": {
                            "type": "integer",
                            "minimum": 16,
                            "maximum": 512,
                            "description": "HNSW: Construction-time search width"
                        },
                        "ef_search": {
                            "type": "integer",
                            "minimum": 10,
                            "maximum": 500,
                            "description": "HNSW: Query-time search width"
                        },
                        "vector_weight": {
                            "type": "number",
                            "minimum": 0,
                            "maximum": 1,
                            "description": "Hybrid: Weight for vector search component"
                        },
                        "bm25_weight": {
                            "type": "number",
                            "minimum": 0,
                            "maximum": 1,
                            "description": "Hybrid: Weight for BM25 text search component"
                        },
                        "temporal_weight": {
                            "type": "number",
                            "minimum": 0,
                            "maximum": 1,
                            "description": "Hybrid: Weight for temporal recency component"
                        }
                    }
                }
            },
            "required": ["index_type", "action"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "format": {
                    "type": "string",
                    "enum": ["json", "csv", "jsonl"],
                    "default": "json",
                    "description": "Output format for exported data"
                },
                "memory_types": {
                    "type": "array",
                    "minItems": 1,
                    "items": {
                        "type": "string",
                        "enum": ["episodic", "semantic", "procedural", "working"]
                    },
                    "description": "Explicit memory domains to export"
                },
                "tags": {
                    "type": "array",
                    "items": { "type": "string" },
                    "description": "Filter by tags (memories must have at least one matching tag)"
                },
                "after": {
                    "type": "string",
                    "format": "date-time",
                    "description": "Export memories created after this timestamp (ISO 8601)"
                },
                "before": {
                    "type": "string",
                    "format": "date-time",
                    "description": "Export memories created before this timestamp (ISO 8601)"
                }
            },
            "required": ["memory_types"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "include_identity": {
                    "type": "boolean",
                    "default": true,
                    "description": "Include the authenticated agent id and rate-limit tier"
                },
                "include_health": {
                    "type": "boolean",
                    "default": true,
                    "description": "Include backend health information"
                }
            }
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "query_type": {
                    "type": "string",
                    "enum": ["sql", "cypher", "text", "kv"],
                    "default": "sql",
                    "description": "The query language to use"
                },
                "query": {
                    "type": "string",
                    "description": "The raw query string to execute"
                },
                "limit": {
                    "type": "integer",
                    "default": 100,
                    "minimum": 1,
                    "maximum": 10000,
                    "description": "Maximum number of results to return"
                }
            },
            "required": ["query"]
        })
    }

fn input_schema(&self) -> JsonValue {
        json!({
            "type": "object",
            "properties": {
                "include_filters": {
                    "type": "boolean",
                    "default": false,
                    "description": "Include configured enabled/disabled filters"
                }
            }
        })
    }