divi 0.0.1b0__py3-none-any.whl

divi/__init__.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from .decorators import obs_openai, observable
+from .evaluation import Evaluator, Score
+from .services import Auth, Core, DataPark
+from .session import Session
+from .signals import Kind
+
+name: str = "divi"
+
+_session: Optional[Session] = None
+_core: Optional[Core] = None
+_auth: Optional[Auth] = None
+_datapark: Optional[DataPark] = None
+_evaluator: Optional[Evaluator] = None
+
+__version__ = "0.0.1b0"
+__all__ = ["obs_openai", "observable", "Score", "Kind"]

divi/decorators/__init__.py

@@ -0,0 +1,4 @@
+from .obs_openai import obs_openai
+from .observable import observable
+
+__all__ = ["observable", "obs_openai"]

divi/decorators/collect.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+from google.protobuf.message import Error
+from openai.types.chat import ChatCompletion
+from typing_extensions import Dict
+
+import divi
+from divi.evaluation.evaluator import EvaluationScore
+from divi.signals.span import Span
+
+
+def collect(span: Span, input: Dict[str, Any], result: Any):
+    if not divi._datapark or span.trace_id is None:
+        raise Error("divi._datapark or span.trace_id is None")
+    # TODO: collect inputs and outputs for SPAN_KIND_FUNCTION
+
+    # collect inputs and outputs for SPAN_KIND_LLM
+    if isinstance(result, ChatCompletion):
+        divi._datapark.create_chat_completion(
+            span_id=span.span_id,
+            trace_id=span.trace_id,
+            inputs=input,
+            completion=result,
+        )
+
+    # collect inputs and outputs for SPAN_KIND_EVALUATION
+    if isinstance(result, list) and all(
+        isinstance(x, EvaluationScore) for x in result
+    ):
+        divi._datapark.create_scores(
+            span_id=span.span_id,
+            trace_id=span.trace_id,
+            scores=result,
+        )

divi/decorators/obs_openai.py

@@ -0,0 +1,48 @@
+import functools
+from collections.abc import Callable
+from typing import TYPE_CHECKING, TypeVar, Union
+
+from typing_extensions import Optional
+
+from divi.decorators.observable import observable
+from divi.evaluation.scores import Score
+from divi.signals.span import Kind
+from divi.utils import is_async
+
+if TYPE_CHECKING:
+    from openai import AsyncOpenAI, OpenAI
+
+C = TypeVar("C", bound=Union["OpenAI", "AsyncOpenAI"])
+
+
+def _get_observable_create(
+    create: Callable,
+    name: Optional[str] = None,
+    scores: Optional[list[Score]] = None,
+) -> Callable:
+    @functools.wraps(create)
+    def observable_create(*args, stream: bool = False, **kwargs):
+        decorator = observable(kind=Kind.llm, name=name, scores=scores)
+        return decorator(create)(*args, stream=stream, **kwargs)
+
+    # TODO Async Observable Create
+    return observable_create if not is_async(create) else create
+
+
+def obs_openai(
+    client: C,
+    name: Optional[str] = "Agent",
+    scores: Optional[list[Score]] = None,
+) -> C:
+    """Make OpenAI client observable."""
+    client.chat.completions.create = _get_observable_create(
+        client.chat.completions.create,
+        name=name,
+        scores=scores,
+    )
+    client.completions.create = _get_observable_create(
+        client.completions.create,
+        name=name,
+        scores=scores,
+    )
+    return client

divi/decorators/observable.py

@@ -0,0 +1,91 @@
+import functools
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    Mapping,
+    Optional,
+    ParamSpec,
+    Protocol,
+    TypeVar,
+    Union,
+    overload,
+    runtime_checkable,
+)
+
+from divi.decorators.observe import observe
+from divi.evaluation.evaluate import evaluate_scores
+from divi.evaluation.scores import Score
+from divi.session import SessionExtra
+from divi.signals.span import Kind, Span
+
+R = TypeVar("R", covariant=True)
+P = ParamSpec("P")
+
+
+@runtime_checkable
+class WithSessionExtra(Protocol, Generic[P, R]):
+    def __call__(
+        self,
+        *args: P.args,
+        session_extra: Optional[SessionExtra] = None,  # type: ignore[valid-type]
+        **kwargs: P.kwargs,
+    ) -> R: ...
+
+
+@overload
+def observable(func: Callable[P, R]) -> WithSessionExtra[P, R]: ...
+
+
+@overload
+def observable(
+    kind: Kind = Kind.function,
+    *,
+    name: Optional[str] = None,
+    scores: Optional[list[Score]] = None,
+    metadata: Optional[Mapping[str, Any]] = None,
+) -> Callable[[Callable[P, R]], WithSessionExtra[P, R]]: ...
+
+
+def observable(
+    *args, **kwargs
+) -> Union[Callable, Callable[[Callable], Callable]]:
+    """Observable decorator factory."""
+
+    kind = kwargs.pop("kind", Kind.function)
+    name = kwargs.pop("name", None)
+    metadata = kwargs.pop("metadata", None)
+    scores: list[Score] = kwargs.pop("scores", None)
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(
+            *args, session_extra: Optional[SessionExtra] = None, **kwargs
+        ):
+            # 1. init the span
+            span = Span(
+                kind=kind, name=name or func.__name__, metadata=metadata
+            )
+
+            # 2. observe the function
+            result = observe(
+                *args,
+                func=func,
+                span=span,
+                session_extra=session_extra,
+                **kwargs,
+            )
+
+            # 3. evaluate the scores if they are provided
+            messages = kwargs.get("messages", [])
+            evaluate_scores(messages, outputs=result, scores=scores)
+
+            return result
+
+        return wrapper
+
+    # Function Decorator
+    if len(args) == 1 and callable(args[0]) and not kwargs:
+        return decorator(args[0])
+    # Factory Decorator
+    return decorator

divi/decorators/observe.py

@@ -0,0 +1,47 @@
+import contextvars
+from typing import (
+    Callable,
+    Optional,
+)
+
+from divi.decorators.collect import collect
+from divi.session import SessionExtra
+from divi.session.setup import setup
+from divi.signals.span import Span
+from divi.utils import extract_flattened_inputs
+
+# ContextVar to store the extra information
+# from the Session and parent Span
+_SESSION_EXTRA = contextvars.ContextVar[Optional[SessionExtra]](
+    "_SESSION_EXTRA", default=None
+)
+
+
+def observe(
+    *args,
+    func: Callable,
+    span: Span,
+    session_extra: Optional[SessionExtra] = None,
+    **kwargs,
+):
+    session_extra = setup(span, _SESSION_EXTRA.get() or session_extra)
+    # set current context
+    token = _SESSION_EXTRA.set(session_extra)
+    # execute the function
+    span.start()
+    result = func(*args, **kwargs)
+    span.end()
+    # recover parent context
+    _SESSION_EXTRA.reset(token)
+
+    # get the trace to collect data
+    trace = session_extra.get("trace")
+    # end the trace if it is the root span
+    if trace and not span.parent_span_id:
+        trace.end()
+
+    # collect inputs and outputs
+    inputs = extract_flattened_inputs(func, *args, **kwargs)
+    collect(span, inputs, result)
+
+    return result

divi/evaluation/__init__.py

@@ -0,0 +1,4 @@
+from .evaluator import Evaluator
+from .scores import Score
+
+__all__ = ["Evaluator", "Score"]

divi/evaluation/evaluate.py

@@ -0,0 +1,61 @@
+import os
+from typing import Optional
+
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionMessageParam,
+)
+from typing_extensions import List
+
+import divi
+from divi.decorators.observe import observe
+from divi.evaluation import Evaluator
+from divi.evaluation.evaluator import EvaluatorConfig
+from divi.evaluation.scores import Score
+from divi.signals.span import Kind, Span
+
+OPENAI_API_KEY = "OPENAI_API_KEY"
+OPENAI_BASE_URL = "OPENAI_BASE_URL"
+
+
+def init_evaluator(config: Optional[EvaluatorConfig] = None):
+    _config = config or EvaluatorConfig()
+    api_key = _config.api_key if _config.api_key else os.getenv(OPENAI_API_KEY)
+    base_url = (
+        _config.base_url if _config.base_url else os.getenv(OPENAI_BASE_URL)
+    )
+    if api_key is None:
+        raise ValueError("API key is required for evaluator")
+    _config.api_key = api_key
+    _config.base_url = base_url
+    evaluator = Evaluator(_config)
+    return evaluator
+
+
+def evaluate_scores(
+    messages: Optional[List[ChatCompletionMessageParam]],
+    outputs: Optional[ChatCompletion],
+    scores: Optional[List[Score]],
+    config: Optional[EvaluatorConfig] = None,
+):
+    if messages is None or scores is None or scores.__len__() == 0:
+        return
+    if not divi._evaluator:
+        divi._evaluator = init_evaluator(config)
+
+    if isinstance(outputs, ChatCompletion):
+        output_message = outputs.choices[0].message.content
+        if not output_message:
+            return
+
+        evaluation_span = Span(kind=Kind.evaluation, name="Evaluation")
+        observe(
+            func=divi._evaluator.evaluate,
+            span=evaluation_span,
+            target=output_message,
+            conversation="\n".join(
+                f"{m.get('role', 'unknown')}: {m.get('content')}"
+                for m in messages
+            ),
+            scores=scores,
+        )

divi/evaluation/evaluator.py

@@ -0,0 +1,174 @@
+import asyncio
+import concurrent.futures
+import random
+from typing import List, Literal, Optional
+
+import openai
+from pydantic import BaseModel
+
+from divi.evaluation.prompts import PRESET_PROMPT, PROMPT_TEMPLATE
+from divi.evaluation.scores import Score
+
+
+class EvaluatorConfig:
+    def __init__(
+        self,
+        model: str = "gpt-4.1-nano",
+        temperature: float = 0.5,
+        max_concurrency: int = 10,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+    ):
+        self.model = model
+        self.api_key = api_key
+        self.base_url = base_url
+        self.temperature = temperature
+        self.max_concurrency = max_concurrency
+
+
+class EvaluationResult(BaseModel):
+    name: Score
+    judgment: bool
+    reasoning: str
+
+
+class EvaluationScore(BaseModel):
+    name: Score
+    score: float
+    representative_reasoning: str
+    all_evaluations: List[EvaluationResult]
+
+
+class Evaluator:
+    def __init__(self, config: Optional[EvaluatorConfig] = None):
+        self.config = config or EvaluatorConfig()
+        self.async_client = openai.AsyncOpenAI(
+            api_key=self.config.api_key, base_url=self.config.base_url
+        )
+        self.sync_client = openai.OpenAI(
+            api_key=self.config.api_key, base_url=self.config.base_url
+        )
+
+    @staticmethod
+    def generate_prompt(target: str, conversation: str, score: Score) -> str:
+        return PROMPT_TEMPLATE.format(
+            requirements=PRESET_PROMPT[score.value],
+            target=target,
+            conversation=conversation,
+        )
+
+    def _sync_evaluate_once(
+        self, target: str, conversation: str, score: Score
+    ) -> Optional[EvaluationResult]:
+        prompt = self.generate_prompt(target, conversation, score)
+        response = self.sync_client.beta.chat.completions.parse(
+            model=self.config.model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=self.config.temperature,
+            response_format=EvaluationResult,
+        )
+        result = response.choices[0].message.parsed
+        if result is not None:
+            result.name = score
+        return result
+
+    async def _async_evaluate_once(
+        self, target: str, conversation: str, score: Score
+    ) -> Optional[EvaluationResult]:
+        prompt = self.generate_prompt(target, conversation, score)
+        response = await self.async_client.beta.chat.completions.parse(
+            model=self.config.model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=self.config.temperature,
+            response_format=EvaluationResult,
+        )
+        result = response.choices[0].message.parsed
+        if result is not None:
+            result.name = score
+        return result
+
+    def _aggregate_result(
+        self, name: Score, evaluations: List[EvaluationResult]
+    ) -> EvaluationScore:
+        n = len(evaluations)
+        true_count = sum(1 for e in evaluations if e.judgment is True)
+        score = true_count / n
+        majority_judgment = True if true_count >= (n / 2) else False
+        majority_reasons = [
+            e.reasoning for e in evaluations if e.judgment == majority_judgment
+        ]
+        representative_reasoning = (
+            random.choice(majority_reasons) if majority_reasons else ""
+        )
+        return EvaluationScore(
+            name=name,
+            score=score,
+            representative_reasoning=representative_reasoning,
+            all_evaluations=evaluations,
+        )
+
+    def _aggregate_results(
+        self, evaluations: List[EvaluationResult]
+    ) -> List[EvaluationScore]:
+        scores = {}
+        for evaluation in evaluations:
+            if evaluation.name not in scores:
+                scores[evaluation.name] = []
+            scores[evaluation.name].append(evaluation)
+
+        aggregated_results = [
+            self._aggregate_result(name, evals)
+            for name, evals in scores.items()
+        ]
+        return aggregated_results
+
+    def evaluate_sync(
+        self, target: str, conversation: str, scores: list[Score], n_rounds: int
+    ) -> List[EvaluationScore]:
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=self.config.max_concurrency
+        ) as executor:
+            futures = [
+                executor.submit(
+                    self._sync_evaluate_once, target, conversation, score
+                )
+                for _ in range(n_rounds)
+                for score in scores
+            ]
+            evaluations = [
+                f.result() for f in concurrent.futures.as_completed(futures)
+            ]
+        return self._aggregate_results(
+            [e for e in evaluations if e is not None]
+        )
+
+    async def evaluate_async(
+        self, target: str, conversation: str, scores: list[Score], n_rounds: int
+    ) -> List[EvaluationScore]:
+        semaphore = asyncio.Semaphore(self.config.max_concurrency)
+
+        async def sem_task(score):
+            async with semaphore:
+                return await self._async_evaluate_once(
+                    target, conversation, score
+                )
+
+        tasks = [sem_task(score) for _ in range(n_rounds) for score in scores]
+        evaluations = await asyncio.gather(*tasks)
+        return self._aggregate_results(
+            [e for e in evaluations if e is not None]
+        )
+
+    def evaluate(
+        self,
+        target: str,
+        conversation: str,
+        scores: list[Score],
+        n_rounds: int = 5,
+        mode: Literal["sync", "async"] = "sync",
+    ) -> List[EvaluationScore]:
+        if mode == "async":
+            return asyncio.run(
+                self.evaluate_async(target, conversation, scores, n_rounds)
+            )
+        return self.evaluate_sync(target, conversation, scores, n_rounds)

divi/evaluation/prompts.py

@@ -0,0 +1,19 @@
+PROMPT_TEMPLATE = (
+    "The *requirements* of the evaluation task are: {requirements}\n\n"
+    "Below is the *context* of the conversation (for reference only):\n"
+    "{conversation}\n\n"
+    "Now, in view of both the requirements and the context, evaluate the assistant’s response:\n"
+    "{target}\n\n"
+    "Please reason step by step to reach your judgment.\n\n"
+    "Strictly output your answer in the following JSON format:\n"
+    "{{\n"
+    '  "judgment": bool,        # true if the response meets all requirements\n'
+    '  "reasoning": "string"    # concise explanation, hitting only the key points\n'
+    "}}\n"
+    "Do not output anything else."
+)
+
+PRESET_PROMPT = {
+    "task_completion": "Assess whether the assistant response fulfills the user's task requirements.",
+    "instruction_adherence": "Assess whether the assistant response strictly follows every instruction given by the user, without omissions, deviations, or hallucinations.",
+}

divi/evaluation/scores.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class Score(str, Enum):
+    """Enum for score types."""
+
+    task_completion = "task_completion"
+    instruction_adherence = "instruction_adherence"

divi/proto/common/v1/common.proto

@@ -0,0 +1,49 @@
+syntax = "proto3";
+
+package divi.proto.common.v1;
+
+option go_package = "services/pb";
+
+// AnyValue is used to represent any type of attribute value. AnyValue may contain a
+// primitive value such as a string or integer or it may contain an arbitrary nested
+// object containing arrays, key-value lists and primitives.
+message AnyValue {
+  // The value is one of the listed fields. It is valid for all values to be unspecified
+  // in which case this AnyValue is considered to be "empty".
+  oneof value {
+    string string_value = 1;
+    bool bool_value = 2;
+    int64 int_value = 3;
+    double double_value = 4;
+    ArrayValue array_value = 5;
+    KeyValueList kvlist_value = 6;
+    bytes bytes_value = 7;
+  }
+}
+
+// ArrayValue is a list of AnyValue messages. We need ArrayValue as a message
+// since oneof in AnyValue does not allow repeated fields.
+message ArrayValue {
+  // Array of values. The array may be empty (contain 0 elements).
+  repeated AnyValue values = 1;
+}
+
+// KeyValueList is a list of KeyValue messages. We need KeyValueList as a message
+// since `oneof` in AnyValue does not allow repeated fields. Everywhere else where we need
+// a list of KeyValue messages (e.g. in Span) we use `repeated KeyValue` directly to
+// avoid unnecessary extra wrapping (which slows down the protocol). The 2 approaches
+// are semantically equivalent.
+message KeyValueList {
+  // A collection of key/value pairs of key-value pairs. The list may be empty (may
+  // contain 0 elements).
+  // The keys MUST be unique (it is not allowed to have more than one
+  // value with the same key).
+  repeated KeyValue values = 1;
+}
+
+// KeyValue is a key-value pair that is used to store Span attributes, Link
+// attributes, etc.
+message KeyValue {
+  string key = 1;
+  AnyValue value = 2;
+}

divi/proto/common/v1/common_pb2.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: divi/proto/common/v1/common.proto
+# Protobuf Python Version: 5.29.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'divi/proto/common/v1/common.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!divi/proto/common/v1/common.proto\x12\x14\x64ivi.proto.common.v1\"\xfa\x01\n\x08\x41nyValue\x12\x16\n\x0cstring_value\x18\x01 \x01(\tH\x00\x12\x14\n\nbool_value\x18\x02 \x01(\x08H\x00\x12\x13\n\tint_value\x18\x03 \x01(\x03H\x00\x12\x16\n\x0c\x64ouble_value\x18\x04 \x01(\x01H\x00\x12\x37\n\x0b\x61rray_value\x18\x05 \x01(\x0b\x32 .divi.proto.common.v1.ArrayValueH\x00\x12:\n\x0ckvlist_value\x18\x06 \x01(\x0b\x32\".divi.proto.common.v1.KeyValueListH\x00\x12\x15\n\x0b\x62ytes_value\x18\x07 \x01(\x0cH\x00\x42\x07\n\x05value\"<\n\nArrayValue\x12.\n\x06values\x18\x01 \x03(\x0b\x32\x1e.divi.proto.common.v1.AnyValue\">\n\x0cKeyValueList\x12.\n\x06values\x18\x01 \x03(\x0b\x32\x1e.divi.proto.common.v1.KeyValue\"F\n\x08KeyValue\x12\x0b\n\x03key\x18\x01 \x01(\t\x12-\n\x05value\x18\x02 \x01(\x0b\x32\x1e.divi.proto.common.v1.AnyValueB\rZ\x0bservices/pbb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'divi.proto.common.v1.common_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'Z\013services/pb'
+  _globals['_ANYVALUE']._serialized_start=60
+  _globals['_ANYVALUE']._serialized_end=310
+  _globals['_ARRAYVALUE']._serialized_start=312
+  _globals['_ARRAYVALUE']._serialized_end=372
+  _globals['_KEYVALUELIST']._serialized_start=374
+  _globals['_KEYVALUELIST']._serialized_end=436
+  _globals['_KEYVALUE']._serialized_start=438
+  _globals['_KEYVALUE']._serialized_end=508
+# @@protoc_insertion_point(module_scope)

divi/proto/common/v1/common_pb2.pyi

@@ -0,0 +1,44 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class AnyValue(_message.Message):
+    __slots__ = ("string_value", "bool_value", "int_value", "double_value", "array_value", "kvlist_value", "bytes_value")
+    STRING_VALUE_FIELD_NUMBER: _ClassVar[int]
+    BOOL_VALUE_FIELD_NUMBER: _ClassVar[int]
+    INT_VALUE_FIELD_NUMBER: _ClassVar[int]
+    DOUBLE_VALUE_FIELD_NUMBER: _ClassVar[int]
+    ARRAY_VALUE_FIELD_NUMBER: _ClassVar[int]
+    KVLIST_VALUE_FIELD_NUMBER: _ClassVar[int]
+    BYTES_VALUE_FIELD_NUMBER: _ClassVar[int]
+    string_value: str
+    bool_value: bool
+    int_value: int
+    double_value: float
+    array_value: ArrayValue
+    kvlist_value: KeyValueList
+    bytes_value: bytes
+    def __init__(self, string_value: _Optional[str] = ..., bool_value: bool = ..., int_value: _Optional[int] = ..., double_value: _Optional[float] = ..., array_value: _Optional[_Union[ArrayValue, _Mapping]] = ..., kvlist_value: _Optional[_Union[KeyValueList, _Mapping]] = ..., bytes_value: _Optional[bytes] = ...) -> None: ...
+
+class ArrayValue(_message.Message):
+    __slots__ = ("values",)
+    VALUES_FIELD_NUMBER: _ClassVar[int]
+    values: _containers.RepeatedCompositeFieldContainer[AnyValue]
+    def __init__(self, values: _Optional[_Iterable[_Union[AnyValue, _Mapping]]] = ...) -> None: ...
+
+class KeyValueList(_message.Message):
+    __slots__ = ("values",)
+    VALUES_FIELD_NUMBER: _ClassVar[int]
+    values: _containers.RepeatedCompositeFieldContainer[KeyValue]
+    def __init__(self, values: _Optional[_Iterable[_Union[KeyValue, _Mapping]]] = ...) -> None: ...
+
+class KeyValue(_message.Message):
+    __slots__ = ("key", "value")
+    KEY_FIELD_NUMBER: _ClassVar[int]
+    VALUE_FIELD_NUMBER: _ClassVar[int]
+    key: str
+    value: AnyValue
+    def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[AnyValue, _Mapping]] = ...) -> None: ...

divi/proto/core/health/v1/health_service.proto

@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package divi.proto.core.health.v1;
+
+option go_package = "services/pb";
+
+// HealthService is a service that implements health check.
+service HealthService {
+  rpc Check(HealthCheckRequest) returns (HealthCheckResponse) {}
+}
+
+message HealthCheckRequest { string version = 1; }
+
+message HealthCheckResponse {
+  bool status = 1;
+  string message = 2;
+}