forgexa-cli 1.78.0__tar.gz → 1.78.2__tar.gz

{forgexa_cli-1.78.0 → forgexa_cli-1.78.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.78.0
+Version: 1.78.2
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT
@@ -26,6 +26,8 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.24
 Requires-Dist: socksio>=1.0.0
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: pycountry>=24.6
 Provides-Extra: daemon
 Requires-Dist: httpx>=0.24; extra == "daemon"
 Requires-Dist: socksio>=1.0.0; extra == "daemon"

{forgexa_cli-1.78.0 → forgexa_cli-1.78.2}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.78.0"
+__version__ = "1.78.2"

{forgexa_cli-1.78.0 → forgexa_cli-1.78.2}/forgexa_cli/daemon.py

@@ -1234,7 +1234,7 @@ except (ImportError, ModuleNotFoundError):
 # DAEMON_VERSION is the protocol/logic version of the daemon code.
 # Kept in sync with pyproject.toml version via bump-version.sh.
 # CLIENT_TYPE identifies which packaging/distribution this daemon runs in.
-DAEMON_VERSION = "1.78.0"
+DAEMON_VERSION = "1.78.2"
 
 
 def _detect_client_type() -> str:

forgexa_cli-1.78.2/forgexa_cli/observability_contract.py

@@ -0,0 +1,833 @@
+"""Generated by backend/scripts/export_observability_runtime.py; do not edit."""
+from __future__ import annotations
+from typing import Union
+from itertools import zip_longest
+
+def _strict_zip(*iterables):
+    missing = object()
+    for items in zip_longest(*iterables, fillvalue=missing):
+        if any((item is missing for item in items)):
+            raise ValueError('zip() arguments have different lengths')
+        yield items
+import pycountry
+from pydantic import BaseModel
+from pydantic import ConfigDict
+import math
+from typing import Annotated
+from typing import Literal
+from urllib.parse import urlsplit
+from uuid import UUID
+from pydantic import AwareDatetime
+from pydantic import Field
+from pydantic import field_validator
+from pydantic import model_serializer
+from pydantic import model_validator
+import json
+from datetime import datetime
+Provider = Literal['mpulse', 'newrelic']
+ResultType = Literal['summary', 'table', 'timeseries', 'histogram', 'distribution', 'records', 'span', 'trace', 'metadata']
+Identifier = Annotated[str, Field(min_length=1, max_length=256, pattern='^[A-Za-z0-9_.:/-]+$')]
+Scalar = Union[Union[Union[Annotated[str, Field(max_length=2048)], bool], int], float]
+
+class ObservabilityModel(BaseModel):
+    model_config = ConfigDict(extra='forbid', allow_inf_nan=False, hide_input_in_errors=True)
+
+def unique_values(values: list) -> list:
+    if len(values) != len(set(values)):
+        raise ValueError('Values must be unique')
+    return values
+
+def validate_country_code(country: str) -> str:
+    if len(country) != 2 or not country.isupper() or pycountry.countries.get(alpha_2=country) is None:
+        raise ValueError('Invalid ISO country code')
+    return country
+
+class ObservabilityWindow(ObservabilityModel):
+    start_time: AwareDatetime
+    end_time: AwareDatetime
+
+    @model_validator(mode='after')
+    def validate_window(self) -> ObservabilityWindow:
+        if self.start_time >= self.end_time:
+            raise ValueError('Window must have a positive duration')
+        return self
+
+class ObservabilitySelection(ObservabilityModel):
+    field_id: Union[Identifier, Literal['*']]
+    aggregate: Literal['native', 'count', 'sum', 'average', 'mean', 'min', 'max', 'percentile', 'rate', 'uniqueCount', 'apdex', 'histogram']
+    percentile: Union[float, None] = Field(default=None, ge=1, le=99, strict=True)
+    rate_interval_seconds: Union[int, None] = Field(default=None, ge=1, le=86400, strict=True)
+    threshold: Union[float, None] = Field(default=None, gt=0, strict=True)
+
+    @model_validator(mode='after')
+    def validate_arguments(self) -> ObservabilitySelection:
+        arguments = {'percentile': 'percentile', 'rate_interval_seconds': 'rate', 'threshold': 'apdex'}
+        for name, aggregate in arguments.items():
+            required = self.aggregate == aggregate
+            if required != (getattr(self, name) is not None):
+                raise ValueError('Aggregate arguments do not match the selected function')
+            if not required and name in self.model_fields_set:
+                raise ValueError('Aggregate does not accept this argument')
+        if self.field_id == '*' and self.aggregate != 'count':
+            raise ValueError('Wildcard fields are allowed only for count')
+        return self
+
+class ObservabilityCondition(ObservabilityModel):
+    field_id: Identifier
+    operator: Literal['eq', 'neq', 'in', 'not_in', 'gt', 'gte', 'lt', 'lte', 'exists', 'not_exists', 'prefix', 'contains']
+    value: Union[Scalar, None] = Field(default=None, repr=False)
+    values: Union[list[Scalar], None] = Field(default=None, min_length=1, max_length=100, repr=False)
+
+    @model_serializer(mode='wrap')
+    def serialize_operands(self, handler):
+        result = handler(self)
+        for name in ('value', 'values'):
+            if getattr(self, name) is None:
+                result.pop(name, None)
+        return result
+
+    @model_validator(mode='after')
+    def validate_operands(self) -> ObservabilityCondition:
+        supplied = self.model_fields_set & {'value', 'values'}
+        if self.operator in {'exists', 'not_exists'}:
+            if supplied:
+                raise ValueError('Existence conditions do not accept operands')
+        elif self.operator in {'in', 'not_in'}:
+            if supplied != {'values'} or self.values is None:
+                raise ValueError('Set conditions require non-empty values')
+        elif supplied != {'value'} or self.value is None:
+            raise ValueError('Comparison conditions require one non-null value')
+        if self.operator in {'prefix', 'contains'} and (not isinstance(self.value, str)):
+            raise ValueError('Text conditions require a string')
+        return self
+
+class ObservabilityFilterGroup(ObservabilityModel):
+    operator: Literal['and', 'or']
+    conditions: list[Annotated[Union[ObservabilityCondition, ObservabilityFilterGroup], Field(discriminator='operator')]] = Field(min_length=1, max_length=100)
+FilterTree = Annotated[Union[ObservabilityCondition, ObservabilityFilterGroup], Field(discriminator='operator')]
+
+class ObservabilityOrder(ObservabilityModel):
+    field_id: Identifier
+    direction: Literal['asc', 'desc']
+
+class ObservabilityQuery(ObservabilityModel):
+    dataset_id: Identifier
+    result_type: ResultType
+    select: Union[list[ObservabilitySelection], None] = Field(default=None, min_length=1, max_length=50)
+    fields: Union[list[Identifier], None] = Field(default=None, min_length=1, max_length=50)
+    filters: Union[FilterTree, None] = None
+    group_by: list[Identifier] = Field(default_factory=list, max_length=10)
+    order_by: list[ObservabilityOrder] = Field(default_factory=list, max_length=5)
+    interval_seconds: Union[int, None] = Field(default=None, ge=1, le=604800, strict=True)
+    limit: int = Field(default=100, ge=1, le=5000, strict=True)
+
+    @field_validator('filters', mode='before')
+    @classmethod
+    def validate_filter_size(cls, value):
+        pending = [(value, 1)] if value is not None else []
+        count = 0
+        while pending:
+            node, depth = pending.pop()
+            count += 1
+            if depth > 8 or count > 100:
+                raise ValueError('Filter tree exceeds its depth or node limit')
+            if isinstance(node, dict) and isinstance(node.get('conditions'), list):
+                if len(node['conditions']) > 100:
+                    raise ValueError('Filter tree exceeds its node limit')
+                pending.extend(((child, depth + 1) for child in node['conditions']))
+            elif isinstance(node, ObservabilityFilterGroup):
+                pending.extend(((child, depth + 1) for child in node.conditions))
+        return value
+
+    @model_validator(mode='after')
+    def validate_shape(self) -> ObservabilityQuery:
+        projected = self.result_type in {'records', 'span', 'trace', 'metadata'}
+        if projected:
+            if not self.fields or 'select' in self.model_fields_set or self.group_by:
+                raise ValueError('Projected results require fields and reject aggregates or grouping')
+            unique_values(self.fields)
+        elif not self.select or 'fields' in self.model_fields_set:
+            raise ValueError('Aggregate results require selections and reject record projections')
+        unique_values(self.group_by)
+        unique_values([item.field_id for item in self.order_by])
+        if self.interval_seconds is not None and self.result_type != 'timeseries':
+            raise ValueError('Intervals are allowed only for time series')
+        return self
+Sha256 = Annotated[str, Field(pattern='^[a-f0-9]{64}$')]
+CellValue = Union[Union[Union[Union[str, bool], int], float], None]
+CountKind = Literal['measurements', 'aggregate_requests', 'reported_events', 'estimated_events', 'sessions', 'unknown']
+Statistic = Literal['native', 'count', 'sum', 'mean', 'average', 'min', 'max', 'percentile', 'rate', 'uniqueCount', 'apdex']
+
+def validate_issuer(value: str) -> str:
+    try:
+        if any((character.isspace() or ord(character) < 32 for character in value)):
+            raise ValueError
+        parsed = urlsplit(value)
+        parsed.port
+        if not parsed.hostname or parsed.username or parsed.password:
+            raise ValueError
+        if parsed.path not in {'', '/'} or parsed.query or parsed.fragment:
+            raise ValueError
+        if parsed.scheme != 'https' and (not (parsed.scheme == 'http' and parsed.hostname in {'localhost', '127.0.0.1', '::1'})):
+            raise ValueError
+    except ValueError:
+        raise ValueError('observability_invalid_issuer') from None
+    return value
+
+def validate_unit_values(native_value, value, native_unit, display_unit):
+    if native_value is None or value is None:
+        if native_value is not None or value is not None:
+            raise ValueError('observability_inconsistent_missing_value')
+        return
+    conversions = {('seconds', 'milliseconds'): 1000, ('milliseconds', 'seconds'): 0.001, ('ratio', 'percent'): 100, ('percent', 'ratio'): 0.01}
+    scale = 1 if native_unit == display_unit else conversions.get((native_unit, display_unit))
+    if scale is None or not math.isclose(native_value * scale, value, rel_tol=1e-12, abs_tol=1e-12):
+        raise ValueError('observability_unit_conversion_invalid')
+
+class ObservabilityOrigin(ObservabilityModel):
+    issuer: str = Field(min_length=1, max_length=2048)
+    workspace_id: UUID
+    project_id: UUID
+    created_by_user_id: UUID
+    _validate_issuer = field_validator('issuer')(validate_issuer)
+
+class ObservabilityCoverageWindow(ObservabilityWindow):
+    window_index: int = Field(default=0, ge=0, le=4, strict=True)
+
+class ObservabilitySource(ObservabilityModel):
+    source_id: Identifier
+    target_ref: Identifier
+    connection_id: Identifier
+    environment: Identifier
+    endpoint_region: Identifier
+    scope_precision: Literal['dedicated', 'filtered']
+    origin_scope_ids: list[Identifier] = Field(min_length=1, max_length=100)
+    market_codes: list[str] = Field(default_factory=list, max_length=20)
+    application_id: Union[Identifier, None] = None
+    account_id: Union[int, None] = Field(default=None, ge=1, strict=True)
+    entity_guid: Union[str, None] = Field(default=None, min_length=1, max_length=256)
+    material_version: int = Field(ge=1, strict=True)
+    status: Literal['available', 'zero_matches', 'partial', 'unavailable']
+    completed: bool
+    actual_windows: list[ObservabilityCoverageWindow] = Field(default_factory=list, max_length=500)
+
+class ObservabilitySafeCondition(ObservabilityModel):
+    field_id: Identifier
+    operator: Literal['eq', 'neq', 'in', 'not_in', 'gt', 'gte', 'lt', 'lte', 'exists', 'not_exists', 'prefix', 'contains']
+    values_redacted: Literal[True] = True
+
+class ObservabilitySafeFilterGroup(ObservabilityModel):
+    operator: Literal['and', 'or']
+    conditions: list[Annotated[Union[ObservabilitySafeCondition, ObservabilitySafeFilterGroup], Field(discriminator='operator')]] = Field(min_length=1, max_length=100)
+
+class ObservabilityFrozenScope(ObservabilityModel):
+    scope_mode: Literal['common', 'market']
+    scope_ids: list[Identifier] = Field(default_factory=list, max_length=20)
+    country_codes: list[str] = Field(default_factory=list, max_length=20)
+    environment: Union[Identifier, None] = None
+    target_refs: list[Identifier] = Field(min_length=1, max_length=100)
+
+    @model_validator(mode='after')
+    def validate_scope(self) -> ObservabilityFrozenScope:
+        for values in (self.scope_ids, self.country_codes, self.target_refs):
+            unique_values(values)
+        if self.scope_mode == 'common':
+            if not self.scope_ids or self.country_codes or self.environment is not None:
+                raise ValueError('observability_scope_mode_mismatch')
+        elif not self.country_codes or not self.environment or self.scope_ids:
+            raise ValueError('observability_scope_mode_mismatch')
+        for country in self.country_codes:
+            validate_country_code(country)
+        return self
+
+class ObservabilitySafeParameters(ObservabilityModel):
+    dataset_id: Identifier
+    request_digest: Sha256
+    field_ids: list[Identifier] = Field(min_length=1, max_length=50)
+    filter_fields: list[Identifier] = Field(default_factory=list, max_length=100)
+    filter_values_redacted: Literal[True] = True
+    filters: Union[Annotated[Union[ObservabilitySafeCondition, ObservabilitySafeFilterGroup], Field(discriminator='operator')], None] = None
+    query_ref: Identifier
+    limit: Union[int, None] = Field(default=None, ge=1, le=5000, strict=True)
+    interval_seconds: Union[int, None] = Field(default=None, ge=1, strict=True)
+    workload_ids: Union[list[Identifier], None] = Field(default=None, min_length=1, max_length=1)
+
+    @model_serializer(mode='wrap')
+    def serialize_optional_workloads(self, handler):
+        value = handler(self)
+        if self.workload_ids is None:
+            value.pop('workload_ids', None)
+        return value
+
+    @field_validator('filters', mode='before')
+    @classmethod
+    def validate_filter_size(cls, value):
+        if isinstance(value, ObservabilityModel):
+            value = value.model_dump()
+        return ObservabilityQuery.validate_filter_size(value)
+
+def validate_redacted_value(value, mode):
+    if value is None or mode == 'none':
+        return
+    valid = value == '[REDACTED]' if mode == 'mask' else isinstance(value, str) and value.startswith('sha256:') and (len(value) == 71) and all((character in '0123456789abcdef' for character in value[7:]))
+    if not valid:
+        raise ValueError('observability_redacted_value_invalid')
+
+class ObservabilityColumn(ObservabilityModel):
+    field_id: Identifier
+    value_type: Literal['string', 'number', 'integer', 'boolean', 'timestamp']
+    classification: Literal['aggregate', 'identifier', 'text']
+    native_unit: Union[str, None] = Field(default=None, min_length=1, max_length=128)
+    display_unit: Union[str, None] = Field(default=None, min_length=1, max_length=128)
+    definition_version: int = Field(default=1, ge=1, strict=True)
+    statistic: Union[Statistic, None] = None
+    percentile: Union[float, None] = Field(default=None, ge=1, le=99, strict=True)
+    redaction: Literal['none', 'mask', 'sha256'] = 'none'
+    native_value_type: Union[Literal['string', 'number', 'integer', 'boolean', 'timestamp'], None] = None
+
+    @model_validator(mode='after')
+    def validate_statistic(self) -> ObservabilityColumn:
+        if (self.statistic == 'percentile') != (self.percentile is not None):
+            raise ValueError('observability_percentile_required')
+        if (self.redaction == 'none') != (self.native_value_type is None) or (self.redaction != 'none' and self.value_type != 'string'):
+            raise ValueError('observability_redacted_column_invalid')
+        return self
+
+    @model_serializer(mode='wrap')
+    def serialize_column(self, handler):
+        value = handler(self)
+        if self.redaction == 'none':
+            value.pop('redaction', None)
+            value.pop('native_value_type', None)
+        return value
+
+class ObservabilityMetricQuality(ObservabilityModel):
+    status: Literal['available', 'missing', 'unsupported', 'unavailable']
+    sampling: Identifier
+    actual_interval_seconds: Union[int, None] = Field(default=None, ge=1, strict=True)
+    provisional: bool = False
+    truncated: bool = False
+
+class ObservabilityMetricValue(ObservabilityWindow):
+    kind: Literal['metric'] = 'metric'
+    evidence_id: Identifier
+    integration_type: Provider
+    evidence_type: Literal['mpulse_data', 'newrelic_data']
+    data_family: Identifier
+    result_type: ResultType
+    source_id: Identifier
+    target_ref: Union[Identifier, None] = None
+    scope_id: Identifier
+    workload_id: Union[Identifier, None] = None
+    window_index: int = Field(default=0, ge=0, le=4, strict=True)
+    metric_id: Identifier
+    definition_version: int = Field(ge=1, strict=True)
+    data_type: Identifier
+    native_metric: str = Field(min_length=1, max_length=256)
+    statistic: Statistic
+    percentile: Union[float, None] = Field(default=None, ge=1, le=99, strict=True)
+    native_unit: str = Field(min_length=1, max_length=128)
+    native_value: Union[float, None] = Field(default=None, strict=True)
+    display_unit: str = Field(min_length=1, max_length=128)
+    value: Union[float, None] = Field(default=None, strict=True)
+    sample_count: Union[int, None] = Field(default=None, ge=0, strict=True)
+    count_kind: CountKind
+    query_ref: Identifier
+    quality: ObservabilityMetricQuality
+
+    @model_validator(mode='after')
+    def validate_measurement(self) -> ObservabilityMetricValue:
+        if self.evidence_type != f'{self.integration_type}_data':
+            raise ValueError('observability_provider_mismatch')
+        if (self.statistic == 'percentile') != (self.percentile is not None):
+            raise ValueError('observability_percentile_required')
+        if self.quality.status == 'available' and self.value is None:
+            raise ValueError('observability_available_value_required')
+        if self.quality.status != 'available' and self.value is not None:
+            raise ValueError('observability_missing_value_must_be_null')
+        if self.statistic == 'percentile' and self.value is not None and (self.sample_count == 0):
+            raise ValueError('observability_empty_percentile_population')
+        validate_unit_values(self.native_value, self.value, self.native_unit, self.display_unit)
+        return self
+
+class ObservabilityRow(ObservabilityModel):
+    kind: Literal['row', 'metadata']
+    item_id: Identifier
+    target_ref: Identifier
+    window_index: int = Field(default=0, ge=0, le=4, strict=True)
+    values: dict[Identifier, CellValue] = Field(min_length=1, max_length=50)
+
+class ObservabilityTimeBucket(ObservabilityWindow):
+    item_id: Identifier
+    native_value: Union[float, None] = Field(default=None, strict=True)
+    value: Union[float, None] = Field(default=None, strict=True)
+    sample_count: Union[int, None] = Field(default=None, ge=0, strict=True)
+
+class ObservabilitySeries(ObservabilityModel):
+    kind: Literal['series']
+    item_id: Identifier
+    target_ref: Identifier
+    window_index: int = Field(default=0, ge=0, le=4, strict=True)
+    field_id: Identifier
+    dimensions: dict[Identifier, CellValue] = Field(default_factory=dict, max_length=10)
+    native_unit: str = Field(min_length=1, max_length=128)
+    display_unit: str = Field(min_length=1, max_length=128)
+    count_kind: CountKind
+    statistic: Statistic
+    percentile: Union[float, None] = Field(default=None, ge=1, le=99, strict=True)
+    buckets: list[ObservabilityTimeBucket] = Field(min_length=1, max_length=50000)
+
+    @model_serializer(mode='wrap')
+    def preserve_legacy_series(self, handler):
+        result = handler(self)
+        if not self.dimensions:
+            result.pop('dimensions', None)
+        return result
+
+    @model_validator(mode='after')
+    def validate_buckets(self) -> ObservabilitySeries:
+        if (self.statistic == 'percentile') != (self.percentile is not None):
+            raise ValueError('observability_percentile_required')
+        for bucket in self.buckets:
+            validate_unit_values(bucket.native_value, bucket.value, self.native_unit, self.display_unit)
+        for previous, current in zip(self.buckets, self.buckets[1:]):
+            if previous.end_time > current.start_time:
+                raise ValueError('observability_time_buckets_overlap')
+        return self
+
+class ObservabilityHistory(ObservabilityModel):
+    kind: Literal['history'] = 'history'
+    item_id: Identifier
+    target_ref: Identifier
+    window_index: int = Field(default=0, ge=0, le=4, strict=True)
+    field_id: Identifier
+    axis: Literal['sample_index'] = 'sample_index'
+    data_timezone: Union[str, None] = Field(default=None, max_length=128)
+    native_unit: str = Field(min_length=1, max_length=128)
+    display_unit: str = Field(min_length=1, max_length=128)
+    statistic: Statistic
+    percentile: Union[float, None] = Field(default=None, ge=1, le=99, strict=True)
+    count_kind: CountKind
+    native_values: list[Union[float, None]] = Field(max_length=50000)
+    values: list[Union[float, None]] = Field(max_length=50000)
+    latest_native_value: Union[float, None] = Field(default=None, strict=True)
+    latest_value: Union[float, None] = Field(default=None, strict=True)
+
+    @field_validator('native_values', 'values', mode='before')
+    @classmethod
+    def numeric_history(cls, values):
+        if not isinstance(values, list) or any((value is not None and type(value) not in {int, float} for value in values)):
+            raise ValueError('observability_history_value_invalid')
+        return values
+
+    @model_validator(mode='after')
+    def validate_history(self):
+        if not self.native_values and self.latest_native_value is None:
+            raise ValueError('observability_history_empty')
+        if len(self.native_values) != len(self.values) or (self.statistic == 'percentile') != (self.percentile is not None):
+            raise ValueError('observability_history_semantics_invalid')
+        for native_value, value in _strict_zip(self.native_values, self.values):
+            validate_unit_values(native_value, value, self.native_unit, self.display_unit)
+        validate_unit_values(self.latest_native_value, self.latest_value, self.native_unit, self.display_unit)
+        return self
+
+class ObservabilityDistributionBucket(ObservabilityModel):
+    item_id: Identifier
+    lower: Union[float, None] = Field(default=None, strict=True)
+    upper: Union[float, None] = Field(default=None, strict=True)
+    count: Union[int, None] = Field(default=None, ge=0, strict=True)
+    native_value: Union[float, None] = Field(default=None, strict=True)
+    value: Union[float, None] = Field(default=None, strict=True)
+
+    @model_validator(mode='after')
+    def validate_edges(self) -> ObservabilityDistributionBucket:
+        if self.lower is not None and self.upper is not None and (self.lower >= self.upper):
+            raise ValueError('observability_distribution_edges_invalid')
+        return self
+
+class ObservabilityDistribution(ObservabilityModel):
+    kind: Literal['distribution']
+    item_id: Identifier
+    target_ref: Identifier
+    window_index: int = Field(default=0, ge=0, le=4, strict=True)
+    field_id: Identifier
+    measurement_unit: str = Field(min_length=1, max_length=128)
+    native_unit: Union[str, None] = Field(default=None, min_length=1, max_length=128)
+    display_unit: Union[str, None] = Field(default=None, min_length=1, max_length=128)
+    count_kind: CountKind
+    buckets: list[ObservabilityDistributionBucket] = Field(min_length=1, max_length=50000)
+
+    @model_validator(mode='after')
+    def validate_values(self) -> ObservabilityDistribution:
+        for bucket in self.buckets:
+            if bucket.value is not None or bucket.native_value is not None:
+                if self.native_unit is None or self.display_unit is None:
+                    raise ValueError('observability_distribution_value_units_required')
+                validate_unit_values(bucket.native_value, bucket.value, self.native_unit, self.display_unit)
+        return self
+
+class ObservabilitySpan(ObservabilityModel):
+    kind: Literal['span']
+    item_id: Identifier
+    target_ref: Identifier
+    window_index: int = Field(default=0, ge=0, le=4, strict=True)
+    trace_id: Identifier
+    span_id: Identifier
+    parent_span_id: Union[Identifier, None] = None
+    parent_missing: bool
+    values: dict[Identifier, CellValue] = Field(default_factory=dict, max_length=50)
+
+class ObservabilityRedactedItem(ObservabilityModel):
+    kind: Literal['redacted']
+    item_id: Identifier
+    target_ref: Identifier
+    window_index: int = Field(default=0, ge=0, le=4, strict=True)
+    original_kind: Literal['metric', 'series', 'history', 'distribution', 'span']
+    value_scope: Literal['whole_field_structure']
+    quality: Union[ObservabilityMetricQuality, None] = None
+    primary_field_id: Union[Identifier, None] = None
+    bucket_refs: list[Identifier] = Field(default_factory=list, max_length=1000)
+    values: dict[Identifier, CellValue] = Field(min_length=1, max_length=50)
+
+    @model_validator(mode='after')
+    def validate_representation(self):
+        unique_values(self.bucket_refs)
+        if self.original_kind == 'span':
+            if self.primary_field_id is not None or self.bucket_refs:
+                raise ValueError('observability_redacted_structure_invalid')
+        elif self.primary_field_id not in self.values or (self.bucket_refs and self.original_kind not in {'series', 'distribution'}):
+            raise ValueError('observability_redacted_structure_invalid')
+        return self
+DataItem = Annotated[Union[Union[Union[Union[Union[Union[ObservabilityMetricValue, ObservabilityRow], ObservabilitySeries], ObservabilityHistory], ObservabilityDistribution], ObservabilitySpan], ObservabilityRedactedItem], Field(discriminator='kind')]
+
+class ObservabilitySnapshotQuality(ObservabilityModel):
+    status: Literal['available', 'zero_matches', 'partial', 'unavailable']
+    completed: bool
+    sampling: Identifier
+    truncated: bool = False
+    limitations: list[Identifier] = Field(default_factory=list, max_length=32)
+
+class ObservabilitySnapshotPayload(ObservabilityModel):
+    schema_version: Literal[1] = 1
+    snapshot_id: UUID
+    integration_type: Provider
+    evidence_type: Literal['mpulse_data', 'newrelic_data']
+    origin: ObservabilityOrigin
+    data_family: Identifier
+    result_type: ResultType
+    config_version: int = Field(ge=1, strict=True)
+    catalog_version: int = Field(ge=1, strict=True)
+    policy_version: int = Field(ge=1, strict=True)
+    source_signature: Sha256
+    recipe_dependencies: dict[Identifier, Sha256] = Field(min_length=1, max_length=50)
+    scope: ObservabilityFrozenScope
+    sources: list[ObservabilitySource] = Field(min_length=1, max_length=100)
+    parameters: ObservabilitySafeParameters
+    requested_windows: list[ObservabilityWindow] = Field(min_length=1, max_length=5)
+    actual_windows: list[ObservabilityCoverageWindow] = Field(default_factory=list, max_length=500)
+    columns: list[ObservabilityColumn] = Field(min_length=1, max_length=50)
+    data: list[DataItem] = Field(max_length=50000)
+    quality: ObservabilitySnapshotQuality
+    collected_at: AwareDatetime
+    expires_at: AwareDatetime
+
+    @model_validator(mode='after')
+    def validate_dataset(self) -> ObservabilitySnapshotPayload:
+        if self.evidence_type != f'{self.integration_type}_data':
+            raise ValueError('observability_provider_mismatch')
+        if not self.parameters.dataset_id.startswith(f'{self.integration_type}.'):
+            raise ValueError('observability_dataset_provider_mismatch')
+        if self.expires_at <= self.collected_at:
+            raise ValueError('observability_expiry_invalid')
+        source_refs = [source.target_ref for source in self.sources]
+        unique_values(source_refs)
+        unique_values([source.source_id for source in self.sources])
+        if set(source_refs) != set(self.scope.target_refs):
+            raise ValueError('observability_target_set_mismatch')
+        for source in self.sources:
+            unique_values(source.origin_scope_ids)
+            unique_values(source.market_codes)
+            for country in source.market_codes:
+                validate_country_code(country)
+            if self.integration_type == 'mpulse':
+                if not source.application_id or source.account_id is not None or source.entity_guid:
+                    raise ValueError('observability_source_identity_invalid')
+                if source.endpoint_region != 'mpulse.soasta.com':
+                    raise ValueError('observability_source_region_invalid')
+            elif source.application_id or source.account_id is None or (not source.entity_guid):
+                raise ValueError('observability_source_identity_invalid')
+            elif source.endpoint_region not in {'US', 'EU', 'JP'}:
+                raise ValueError('observability_source_region_invalid')
+            if source.completed and (not source.actual_windows):
+                raise ValueError('observability_completed_coverage_required')
+            if any((window.window_index >= len(self.requested_windows) for window in source.actual_windows)):
+                raise ValueError('observability_coverage_window_invalid')
+        if self.scope.scope_mode == 'common':
+            origins = {value for source in self.sources for value in source.origin_scope_ids}
+            if origins != set(self.scope.scope_ids) or any((source.market_codes for source in self.sources)):
+                raise ValueError('observability_scope_origins_mismatch')
+        else:
+            markets = {value for source in self.sources for value in source.market_codes}
+            if markets != set(self.scope.country_codes) or any((source.environment != self.scope.environment for source in self.sources)):
+                raise ValueError('observability_scope_origins_mismatch')
+        column_map = {column.field_id: column for column in self.columns}
+        unique_values([column.field_id for column in self.columns])
+        unique_values(self.parameters.field_ids)
+        if set(self.parameters.field_ids) != set(column_map):
+            raise ValueError('observability_projection_not_declared')
+        identifiers = []
+        point_count = 0
+        shape_kinds = {'summary': {'metric', 'row'}, 'table': {'row'}, 'records': {'row'}, 'timeseries': {'series', 'history'}, 'histogram': {'distribution'}, 'distribution': {'distribution'}, 'span': {'span'}, 'trace': {'span'}, 'metadata': {'metadata'}}
+        for item in self.data:
+            native_kind = item.original_kind if item.kind == 'redacted' else item.kind
+            if native_kind not in shape_kinds[self.result_type] or item.target_ref not in source_refs:
+                raise ValueError('observability_result_shape_or_target_invalid')
+            if item.window_index >= len(self.requested_windows):
+                raise ValueError('observability_data_window_invalid')
+            identifiers.append(item.evidence_id if item.kind == 'metric' else item.item_id)
+            if item.kind == 'redacted':
+                if not any((name in column_map and column_map[name].redaction != 'none' for name in item.values)):
+                    raise ValueError('observability_redacted_representation_required')
+                if item.primary_field_id and (item.primary_field_id not in column_map or column_map[item.primary_field_id].redaction == 'none'):
+                    raise ValueError('observability_redacted_representation_required')
+                identifiers.extend(item.bucket_refs)
+                point_count += len(item.bucket_refs)
+            if item.kind == 'history':
+                if item.field_id not in column_map:
+                    raise ValueError('observability_projection_not_declared')
+                column = column_map[item.field_id]
+                if column.redaction != 'none':
+                    raise ValueError('observability_redacted_representation_required')
+                if column.statistic != item.statistic or column.percentile != item.percentile:
+                    raise ValueError('observability_statistic_mismatch')
+                point_count += max(1, len(item.values))
+            elif item.kind in {'series', 'distribution'}:
+                if item.field_id not in column_map:
+                    raise ValueError('observability_projection_not_declared')
+                if column_map[item.field_id].redaction != 'none':
+                    raise ValueError('observability_redacted_representation_required')
+                if item.kind == 'series':
+                    column = column_map[item.field_id]
+                    if column.statistic != item.statistic or column.percentile != item.percentile:
+                        raise ValueError('observability_statistic_mismatch')
+                    for field_id, value in item.dimensions.items():
+                        if field_id not in column_map:
+                            raise ValueError('observability_projection_not_declared')
+                        validate_redacted_value(value, column_map[field_id].redaction)
+                        expected = column_map[field_id].value_type
+                        if value is not None and (not (expected == 'number' and type(value) in {int, float} or (expected == 'integer' and type(value) is int) or (expected == 'boolean' and type(value) is bool) or (expected in {'string', 'timestamp'} and isinstance(value, str)))):
+                            raise ValueError('observability_column_type_invalid')
+                identifiers.extend((bucket.item_id for bucket in item.buckets))
+                point_count += len(item.buckets)
+                if self.result_type == 'histogram' and any((bucket.count is None or bucket.value is not None or bucket.native_value is not None for bucket in item.buckets)):
+                    raise ValueError('observability_histogram_requires_native_counts')
+            elif item.kind == 'metric':
+                if item.metric_id not in column_map or item.integration_type != self.integration_type:
+                    raise ValueError('observability_metric_not_declared')
+                if column_map[item.metric_id].redaction != 'none':
+                    raise ValueError('observability_redacted_representation_required')
+                source = next((source for source in self.sources if source.target_ref == item.target_ref))
+                if item.source_id != source.source_id or item.data_family != self.data_family:
+                    raise ValueError('observability_metric_source_mismatch')
+                if item.definition_version != column_map[item.metric_id].definition_version:
+                    raise ValueError('observability_definition_version_mismatch')
+                if column_map[item.metric_id].statistic != item.statistic:
+                    raise ValueError('observability_statistic_mismatch')
+            else:
+                if item.kind == 'span' and any((column.redaction != 'none' for column in self.columns)):
+                    raise ValueError('observability_redacted_representation_required')
+                for field_id, value in item.values.items():
+                    if field_id not in column_map:
+                        raise ValueError('observability_projection_not_declared')
+                    mode = column_map[field_id].redaction
+                    validate_redacted_value(value, mode)
+                    expected = column_map[field_id].value_type
+                    valid = value is None or (expected == 'number' and type(value) in {int, float} or (expected == 'integer' and type(value) is int) or (expected == 'boolean' and type(value) is bool) or (expected in {'string', 'timestamp'} and isinstance(value, str)))
+                    if not valid:
+                        raise ValueError('observability_column_type_invalid')
+                    if value is not None and expected == 'timestamp':
+                        try:
+                            if datetime.fromisoformat(value.replace('Z', '+00:00')).tzinfo is None:
+                                raise ValueError
+                        except ValueError:
+                            raise ValueError('observability_timestamp_invalid') from None
+        unique_values(identifiers)
+        if point_count > 50000 or len(self.data) > 1000:
+            raise ValueError('observability_result_budget_exceeded')
+        if self.result_type == 'timeseries' and len(self.data) > 100:
+            raise ValueError('observability_series_budget_exceeded')
+        if self.result_type == 'trace' and len({item.trace_id for item in self.data if item.kind == 'span'}) > 5:
+            raise ValueError('observability_trace_budget_exceeded')
+        if self.result_type in {'span', 'trace'}:
+            if not {'span.id', 'trace.id', 'parent.id'} <= column_map.keys():
+                raise ValueError('observability_span_identifiers_required')
+            identities = [(item.target_ref, item.window_index, item.trace_id, item.span_id) for item in self.data if item.kind == 'span']
+            unique_values(identities)
+            for item in self.data:
+                if item.kind != 'span':
+                    continue
+                missing = item.parent_span_id is not None and (item.target_ref, item.window_index, item.trace_id, item.parent_span_id) not in identities
+                if item.parent_missing != missing:
+                    raise ValueError('observability_span_parent_coverage_invalid')
+        if self.quality.status == 'zero_matches' and (self.data or not self.quality.completed):
+            raise ValueError('observability_zero_matches_not_proven')
+        if self.quality.status == 'zero_matches' and any((source.status != 'zero_matches' or not source.completed for source in self.sources)):
+            raise ValueError('observability_zero_matches_not_proven')
+        if self.quality.status == 'available' and (not self.quality.completed or any((not source.completed or source.status not in {'available', 'zero_matches'} for source in self.sources))):
+            raise ValueError('observability_complete_target_coverage_required')
+        if self.quality.status == 'available' and (not self.data):
+            raise ValueError('observability_empty_result_not_explained')
+        return self
+
+class ObservabilityAttachmentSelection(ObservabilityModel):
+    request_id: UUID
+    item_refs: list[Identifier] = Field(default_factory=list, max_length=1000)
+    field_ids: list[Identifier] = Field(default_factory=list, max_length=50)
+    representation_version: Literal[1, 2] = 1
+    include_zero_matches: bool = False
+
+    @model_validator(mode='after')
+    def validate_selection(self) -> ObservabilityAttachmentSelection:
+        unique_values(self.item_refs)
+        unique_values(self.field_ids)
+        if self.include_zero_matches:
+            if self.item_refs:
+                raise ValueError('observability_zero_matches_selection_invalid')
+        elif not self.item_refs or not self.field_ids:
+            raise ValueError('observability_attachment_selection_empty')
+        return self
+
+class ObservabilityAttachmentPayload(ObservabilitySnapshotPayload):
+    attachment_id: UUID
+    parent_payload_sha256: Sha256
+    selection: ObservabilityAttachmentSelection
+    redaction_version: int = Field(ge=1, strict=True)
+
+    @model_validator(mode='after')
+    def validate_selected_content(self) -> ObservabilityAttachmentPayload:
+        if self.selection.field_ids != self.parameters.field_ids:
+            raise ValueError('observability_attachment_selection_mismatch')
+        if self.selection.representation_version != 2 and any((column.redaction != 'none' for column in self.columns)):
+            raise ValueError('observability_representation_version_required')
+        selected = set(self.selection.item_refs)
+        represented = set()
+        for item in self.data:
+            reference = item.evidence_id if item.kind == 'metric' else item.item_id
+            if reference in selected:
+                represented.add(reference)
+            elif item.kind == 'redacted' and item.bucket_refs:
+                references = set(item.bucket_refs)
+                if references - selected:
+                    raise ValueError('observability_attachment_selection_mismatch')
+                represented.update(references)
+            elif item.kind in {'series', 'distribution'}:
+                references = {bucket.item_id for bucket in item.buckets}
+                if references - selected:
+                    raise ValueError('observability_attachment_selection_mismatch')
+                represented.update(references)
+            else:
+                raise ValueError('observability_attachment_selection_mismatch')
+        if represented != selected:
+            raise ValueError('observability_attachment_selection_mismatch')
+        if self.selection.include_zero_matches != (self.quality.status == 'zero_matches'):
+            raise ValueError('observability_attachment_zero_matches_mismatch')
+        return self
+
+class ObservabilityEvidenceReference(ObservabilityModel):
+    issuer: str = Field(min_length=1, max_length=2048)
+    workspace_id: UUID
+    project_id: UUID
+    user_id: UUID
+    snapshot_id: UUID
+    attachment_id: UUID
+    integration_type: Provider
+    evidence_type: Literal['mpulse_data', 'newrelic_data']
+    payload_sha256: Sha256
+    parent_payload_sha256: Sha256
+    _validate_issuer = field_validator('issuer')(validate_issuer)
+
+    @model_validator(mode='after')
+    def validate_provider(self) -> ObservabilityEvidenceReference:
+        if self.evidence_type != f'{self.integration_type}_data':
+            raise ValueError('observability_provider_mismatch')
+        return self
+
+class ObservabilityAttachmentMetadata(ObservabilityEvidenceReference):
+    representation_version: Literal[1, 2] = 1
+    schema_version: Literal[1] = 1
+    byte_count: int = Field(ge=1, le=32768, strict=True)
+    expires_at: AwareDatetime
+    policy_version: int = Field(ge=1, strict=True)
+    current_policy_version: int = Field(ge=1, strict=True)
+    redaction_version: int = Field(ge=1, strict=True)
+    allow_agent_transfer: bool
+    allowed_model_providers: list[Identifier] = Field(default_factory=list, max_length=32)
+    consent_required: bool = False
+
+    @model_serializer(mode='wrap')
+    def serialize_metadata(self, handler):
+        value = handler(self)
+        if self.representation_version == 1:
+            value.pop('representation_version', None)
+        if not self.consent_required:
+            value.pop('consent_required', None)
+        return value
+MAX_SNAPSHOT_BYTES = 10 * 1024 * 1024
+
+def canonical_bytes(value: object) -> bytes:
+    try:
+        return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False).encode('utf-8')
+    except (ValueError, TypeError, UnicodeError, RecursionError):
+        raise ValueError('observability_invalid_json') from None
+
+def _unique_object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError('observability_invalid_json')
+        result[key] = value
+    return result
+
+def _invalid_constant(_value):
+    raise ValueError('observability_invalid_json')
+
+def strict_json_loads(payload: bytes, *, max_bytes: int=MAX_SNAPSHOT_BYTES):
+    if not isinstance(payload, bytes) or not payload or len(payload) > max_bytes:
+        raise ValueError('observability_payload_size_invalid')
+    try:
+        value = json.loads(payload.decode('utf-8'), object_pairs_hook=_unique_object, parse_constant=_invalid_constant)
+        canonical_bytes(value)
+        return value
+    except (ValueError, TypeError, UnicodeError, RecursionError):
+        raise ValueError('observability_invalid_json') from None
+ObservabilityModel.model_rebuild()
+ObservabilityWindow.model_rebuild()
+ObservabilitySelection.model_rebuild()
+ObservabilityCondition.model_rebuild()
+ObservabilityFilterGroup.model_rebuild()
+ObservabilityOrder.model_rebuild()
+ObservabilityQuery.model_rebuild()
+ObservabilityOrigin.model_rebuild()
+ObservabilityCoverageWindow.model_rebuild()
+ObservabilitySource.model_rebuild()
+ObservabilitySafeCondition.model_rebuild()
+ObservabilitySafeFilterGroup.model_rebuild()
+ObservabilityFrozenScope.model_rebuild()
+ObservabilitySafeParameters.model_rebuild()
+ObservabilityColumn.model_rebuild()
+ObservabilityMetricQuality.model_rebuild()
+ObservabilityMetricValue.model_rebuild()
+ObservabilityRow.model_rebuild()
+ObservabilityTimeBucket.model_rebuild()
+ObservabilitySeries.model_rebuild()
+ObservabilityHistory.model_rebuild()
+ObservabilityDistributionBucket.model_rebuild()
+ObservabilityDistribution.model_rebuild()
+ObservabilitySpan.model_rebuild()
+ObservabilityRedactedItem.model_rebuild()
+ObservabilitySnapshotQuality.model_rebuild()
+ObservabilitySnapshotPayload.model_rebuild()
+ObservabilityAttachmentSelection.model_rebuild()
+ObservabilityAttachmentPayload.model_rebuild()
+ObservabilityEvidenceReference.model_rebuild()
+ObservabilityAttachmentMetadata.model_rebuild()

forgexa_cli-1.78.2/forgexa_cli/observability_evidence.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from functools import lru_cache
+from importlib import import_module
+
+EVIDENCE_PROTOCOL_VERSION = 1
+PAYLOAD_MAX_BYTES = 32 * 1024
+TURN_MAX_BYTES = 64 * 1024
+ORIGIN_FIELDS = frozenset({"issuer", "workspace_id", "project_id", "user_id"})
+
+
+class EvidenceError(ValueError):
+    pass
+
+
+@lru_cache(maxsize=1)
+def _contract():
+    try:
+        if __package__ == "app":
+            module = import_module("app.schemas.observability_evidence")
+            serialization = import_module("app.observability_lifecycle")
+        else:
+            module = import_module(
+                f"{__package__}.observability_contract" if __package__ else "observability_contract"
+            )
+            serialization = module
+    except ImportError:
+        raise EvidenceError("observability_evidence_protocol_unsupported") from None
+    return (
+        module.ObservabilityEvidenceReference, module.ObservabilityAttachmentMetadata,
+        module.ObservabilityAttachmentPayload,
+        serialization.canonical_bytes, serialization.strict_json_loads,
+    )
+
+
+def validate_reference(reference) -> dict:
+    reference_model, _metadata, _payload, canonical, _loads = _contract()
+    try:
+        parsed = reference_model.model_validate_json(canonical(reference), strict=True)
+        normalized = parsed.model_dump(mode="json")
+        if normalized != reference:
+            raise ValueError
+    except (TypeError, ValueError):
+        raise EvidenceError("observability_evidence_invalid_reference") from None
+    return normalized
+
+
+def validate_payload(
+    reference, metadata, payload, *, expected_origin, model_provider,
+    trusted_transport=False, now=None,
+) -> dict:
+    import hashlib
+
+    if trusted_transport is not True:
+        raise EvidenceError("observability_evidence_trusted_transport_required")
+    reference = validate_reference(reference)
+    if (
+        not isinstance(expected_origin, dict) or set(expected_origin) != ORIGIN_FIELDS
+        or any(reference[key] != expected_origin[key] for key in ORIGIN_FIELDS)
+    ):
+        raise EvidenceError("observability_evidence_identity_mismatch")
+    if not isinstance(payload, str):
+        raise EvidenceError("observability_evidence_invalid_payload")
+    try:
+        encoded = payload.encode("utf-8")
+    except UnicodeError:
+        raise EvidenceError("observability_evidence_invalid_payload") from None
+    if not 1 <= len(encoded) <= PAYLOAD_MAX_BYTES:
+        raise EvidenceError("observability_evidence_size_limit")
+    if hashlib.sha256(encoded).hexdigest() != reference["payload_sha256"]:
+        raise EvidenceError("observability_evidence_integrity_failed")
+    _reference, metadata_model, payload_model, canonical, loads = _contract()
+    try:
+        current = metadata_model.model_validate_json(canonical(metadata), strict=True)
+        parsed = loads(encoded)
+        body = payload_model.model_validate_json(canonical(parsed), strict=True)
+        if canonical(body.model_dump(mode="json")) != encoded:
+            raise ValueError
+    except (TypeError, ValueError):
+        raise EvidenceError("observability_evidence_invalid_payload") from None
+    current_fields = current.model_dump(mode="json")
+    if any(current_fields[key] != value for key, value in reference.items()):
+        raise EvidenceError("observability_evidence_identity_mismatch")
+    if (
+        str(body.snapshot_id) != reference["snapshot_id"]
+        or str(body.attachment_id) != reference["attachment_id"]
+        or body.integration_type != reference["integration_type"]
+        or body.evidence_type != reference["evidence_type"]
+        or body.parent_payload_sha256 != reference["parent_payload_sha256"]
+        or body.origin.issuer != reference["issuer"]
+        or str(body.origin.workspace_id) != reference["workspace_id"]
+        or str(body.origin.project_id) != reference["project_id"]
+        or str(body.origin.created_by_user_id) != reference["user_id"]
+    ):
+        raise EvidenceError("observability_evidence_identity_mismatch")
+    if (
+        current.byte_count != len(encoded)
+        or current.representation_version != body.selection.representation_version
+        or current.redaction_version != body.redaction_version
+        or current.policy_version != body.policy_version
+        or current.current_policy_version < current.policy_version
+    ):
+        raise EvidenceError("observability_evidence_integrity_failed")
+    timestamp = now or datetime.now(timezone.utc)
+    if current.expires_at <= timestamp or body.expires_at < current.expires_at:
+        raise EvidenceError("observability_evidence_expired")
+    if (
+        current.allow_agent_transfer is not True
+        or model_provider not in current.allowed_model_providers
+    ):
+        raise EvidenceError("observability_evidence_policy_denied")
+    return {
+        "reference": reference, "payload_json": payload, "byte_count": len(encoded),
+        "policy_version": current.current_policy_version,
+        "redaction_version": current.redaction_version,
+        "representation_version": current.representation_version,
+        "expires_at": current.expires_at.isoformat(),
+        "model_provider": model_provider, "data_family": body.data_family,
+        "result_type": body.result_type, "field_ids": body.parameters.field_ids,
+    }
+
+
+def validate_turn_budget(payloads: list[bytes]) -> int:
+    total = 0
+    for payload in payloads:
+        if not isinstance(payload, bytes) or not 1 <= len(payload) <= PAYLOAD_MAX_BYTES:
+            raise EvidenceError("observability_evidence_size_limit")
+        total += len(payload)
+        if total > TURN_MAX_BYTES:
+            raise EvidenceError("observability_turn_budget_exceeded")
+    return total

{forgexa_cli-1.78.0 → forgexa_cli-1.78.2}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.78.0
+Version: 1.78.2
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License-Expression: MIT
@@ -26,6 +26,8 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.24
 Requires-Dist: socksio>=1.0.0
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: pycountry>=24.6
 Provides-Extra: daemon
 Requires-Dist: httpx>=0.24; extra == "daemon"
 Requires-Dist: socksio>=1.0.0; extra == "daemon"

{forgexa_cli-1.78.0 → forgexa_cli-1.78.2}/forgexa_cli.egg-info/SOURCES.txt

@@ -9,6 +9,8 @@ forgexa_cli/aws_evidence.py
 forgexa_cli/aws_logs_evidence.py
 forgexa_cli/daemon.py
 forgexa_cli/main.py
+forgexa_cli/observability_contract.py
+forgexa_cli/observability_evidence.py
 forgexa_cli/py.typed
 forgexa_cli/runtime_evidence.py
 forgexa_cli/zcode_protocol.py

{forgexa_cli-1.78.0 → forgexa_cli-1.78.2}/forgexa_cli.egg-info/requires.txt

@@ -1,5 +1,7 @@
 httpx>=0.24
 socksio>=1.0.0
+pydantic<3,>=2.10
+pycountry>=24.6
 
 [daemon]
 httpx>=0.24

{forgexa_cli-1.78.0 → forgexa_cli-1.78.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.78.0"
+version = "1.78.2"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = "MIT"
@@ -28,7 +28,7 @@ classifiers = [
 # installs it automatically — no fragile runtime auto-install needed.
 # socksio is required for SOCKS proxy support (httpx picks up ALL_PROXY/SOCKS_PROXY env vars
 # automatically, and raises ImportError if socksio is missing).
-dependencies = ["httpx>=0.24", "socksio>=1.0.0"]
+dependencies = ["httpx>=0.24", "socksio>=1.0.0", "pydantic>=2.10,<3", "pycountry>=24.6"]
 
 [project.optional-dependencies]
 # Keep [daemon] extra for backward compatibility / explicit opt-in.