@theowlops/boombot 0.0.0-stage → 1.1.1

package/dist/node_modules/@boombot/security/security/audit.js

@@ -0,0 +1,70 @@
+/**
+ * @boombot/security — audit log.
+ *
+ * Append-only audit trail for security-sensitive operations (secret
+ * lifecycle, approval decisions, sandbox escalations, memory revoke/
+ * forget). Sinks are append-only by contract; this package ships an
+ * in-memory sink for tests and single-process hosts. Production hosts
+ * should wire a durable sink (SQLite table, signed log file).
+ */
+import { randomUUID } from 'node:crypto';
+/** Keys whose values are treated as secrets and redacted. */
+const SECRET_KEY_PATTERN = /(token|secret|password|passwd|api[_-]?key|private[_-]?key|bearer|credential)/i;
+const REDACTED = '[REDACTED]';
+function redactValue(key, value) {
+    if (SECRET_KEY_PATTERN.test(key))
+        return REDACTED;
+    if (typeof value === 'string' && /^(sk-|xox[bap]-|gh[op]_|ya29\.)/.test(value))
+        return REDACTED;
+    if (Array.isArray(value))
+        return value.map((v) => redactValue(key, v));
+    if (typeof value === 'object' && value !== null) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = redactValue(k, v);
+        return out;
+    }
+    return value;
+}
+/** Redact secret-looking entries from audit metadata (defense in depth). */
+export function redactAuditMeta(meta) {
+    if (meta === undefined)
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(meta))
+        out[k] = redactValue(k, v);
+    return out;
+}
+/** In-memory audit sink. Bounded (default 10k events, oldest dropped first). */
+export class InMemoryAuditSink {
+    maxEvents;
+    events = [];
+    constructor(maxEvents = 10_000) {
+        this.maxEvents = maxEvents;
+    }
+    append(event) {
+        const stored = Object.freeze({
+            id: randomUUID(),
+            ts: new Date().toISOString(),
+            actor: event.actor,
+            action: event.action,
+            ...(event.target !== undefined ? { target: event.target } : {}),
+            ...(event.meta !== undefined ? { meta: Object.freeze(redactAuditMeta(event.meta)) ?? {} } : {}),
+        });
+        this.events.push(stored);
+        while (this.events.length > this.maxEvents)
+            this.events.shift();
+        return stored;
+    }
+    /** Newest last. Returns a copy — the log itself is immutable. */
+    list() {
+        return [...this.events];
+    }
+    /** Filter by action prefix, e.g. 'approval.'. */
+    query(actionPrefix) {
+        return this.events.filter((e) => e.action.startsWith(actionPrefix));
+    }
+    get size() {
+        return this.events.length;
+    }
+}

package/dist/node_modules/@boombot/security/security/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @boombot/security — trust boundary, audit, approval.
+ *
+ * Public surface:
+ * - trust:   `TrustZone`, provenance labels, deterministic zone-crossing policy
+ * - audit:   `AuditEvent`, `AuditSink`, `InMemoryAuditSink` (secret-redacting)
+ * - approval: `ApprovalPolicy`, `DefaultApprovalPolicy` (risk floors),
+ *            `deriveSubagentPolicy` (child never looser than parent)
+ */
+export { isTrustedZone, createAuthenticatedPrincipal, labelData, isTrustedData, evaluateCrossing, assertTrusted, type TrustZone, type Principal, type DataSource, type LabeledData, type BoundaryCrossing, type CrossingVerdict, type CrossingDecision, } from './trust.js';
+export { InMemoryAuditSink, redactAuditMeta, type AuditEvent, type NewAuditEvent, type AuditSink, } from './audit.js';
+export { DefaultApprovalPolicy, deriveSubagentPolicy, type ApprovalPolicy, type ApprovalPolicyOptions, type ApprovalDecision, type PolicyEvaluation, type ToolCall, } from './approval.js';

package/dist/node_modules/@boombot/security/security/index.js

@@ -0,0 +1,12 @@
+/**
+ * @boombot/security — trust boundary, audit, approval.
+ *
+ * Public surface:
+ * - trust:   `TrustZone`, provenance labels, deterministic zone-crossing policy
+ * - audit:   `AuditEvent`, `AuditSink`, `InMemoryAuditSink` (secret-redacting)
+ * - approval: `ApprovalPolicy`, `DefaultApprovalPolicy` (risk floors),
+ *            `deriveSubagentPolicy` (child never looser than parent)
+ */
+export { isTrustedZone, createAuthenticatedPrincipal, labelData, isTrustedData, evaluateCrossing, assertTrusted, } from './trust.js';
+export { InMemoryAuditSink, redactAuditMeta, } from './audit.js';
+export { DefaultApprovalPolicy, deriveSubagentPolicy, } from './approval.js';

package/dist/node_modules/@boombot/security/security/trust.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @boombot/security — trust boundary model.
+ *
+ * Consistent with the root SECURITY.md trust model:
+ * "trusted gateway, untrusted execution, deterministic policy".
+ *
+ * Zones:
+ * - `gateway`   — trusted. Authenticated principals, validated commands,
+ *                 policy decisions. Code here decides; it never executes
+ *                 untrusted content.
+ * - `execution` — UNTRUSTED. Sandboxed subprocesses, tool side effects,
+ *                 LLM-generated content. Anything coming out of this zone
+ *                 is treated as hostile input until re-validated.
+ * - `external`  — UNTRUSTED. Network, chat channels, user keystrokes.
+ *
+ * The single hard rule: trust never flows from `execution`/`external`
+ * into `gateway` implicitly — every crossing must be an explicit,
+ * validated, audited decision.
+ */
+/** The three trust zones of an BoomBot deployment. */
+export type TrustZone = 'gateway' | 'execution' | 'external';
+/** Whether a zone is trusted to make security decisions. */
+export declare function isTrustedZone(zone: TrustZone): boolean;
+/** Who is acting. The id must come from authentication, never user input. */
+export interface Principal {
+    /** Stable id resolved by the gateway's authN layer. */
+    readonly id: string;
+    readonly kind: 'user' | 'service' | 'agent';
+}
+/**
+ * Create an authenticated principal. Call ONLY with an id the gateway has
+ * already authenticated (session token, mTLS identity, …). Passing a raw
+ * user-supplied string here is a principal-impersonation vulnerability.
+ */
+export declare function createAuthenticatedPrincipal(id: string, kind?: Principal['kind']): Principal;
+/** Where a piece of data came from. */
+export type DataSource = 'config' | 'user-input' | 'tool-output' | 'llm-output' | 'external';
+/** A data value carrying its provenance label. */
+export interface LabeledData<T> {
+    readonly value: T;
+    readonly source: DataSource;
+    readonly zone: TrustZone;
+}
+/** Attach a provenance label. Labels are the only trust signal — never inferred. */
+export declare function labelData<T>(value: T, source: DataSource, zone: TrustZone): LabeledData<T>;
+/** True only for operator config inside the gateway zone. */
+export declare function isTrustedData<T>(data: LabeledData<T>): boolean;
+export type CrossingVerdict = 'allow' | 'deny';
+/** A request to move data or control across a zone boundary. */
+export interface BoundaryCrossing {
+    readonly from: TrustZone;
+    readonly to: TrustZone;
+    /** What is crossing: data payload, or a control decision. */
+    readonly kind: 'data' | 'control';
+    /** Provenance label of the payload (for kind='data'). */
+    readonly source?: DataSource;
+}
+export interface CrossingDecision {
+    readonly verdict: CrossingVerdict;
+    readonly reason: string;
+}
+/**
+ * Deterministic policy for zone crossings.
+ *
+ * - gateway → anywhere: allow (trusted decisions flow outward).
+ * - external/execution → gateway, kind='control': DENY. Untrusted zones
+ *   never issue control decisions; they only submit data for validation.
+ * - external/execution → gateway, kind='data': allow ONLY when the data
+ *   carries an explicit untrusted label — the gateway must validate it
+ *   (schema, bounds, sanitization) before use. The label is preserved.
+ * - execution → external: allow (egress), but the host should apply
+ *   egress filtering (secret redaction) — see audit.ts.
+ */
+export declare function evaluateCrossing(crossing: BoundaryCrossing): CrossingDecision;
+/**
+ * Assert that a value is trusted before using it in a security decision
+ * (policy evaluation, authZ, command routing). Throws otherwise.
+ */
+export declare function assertTrusted<T>(data: LabeledData<T>, context: string): T;

package/dist/node_modules/@boombot/security/security/trust.js

@@ -0,0 +1,87 @@
+/**
+ * @boombot/security — trust boundary model.
+ *
+ * Consistent with the root SECURITY.md trust model:
+ * "trusted gateway, untrusted execution, deterministic policy".
+ *
+ * Zones:
+ * - `gateway`   — trusted. Authenticated principals, validated commands,
+ *                 policy decisions. Code here decides; it never executes
+ *                 untrusted content.
+ * - `execution` — UNTRUSTED. Sandboxed subprocesses, tool side effects,
+ *                 LLM-generated content. Anything coming out of this zone
+ *                 is treated as hostile input until re-validated.
+ * - `external`  — UNTRUSTED. Network, chat channels, user keystrokes.
+ *
+ * The single hard rule: trust never flows from `execution`/`external`
+ * into `gateway` implicitly — every crossing must be an explicit,
+ * validated, audited decision.
+ */
+/** Whether a zone is trusted to make security decisions. */
+export function isTrustedZone(zone) {
+    return zone === 'gateway';
+}
+/**
+ * Create an authenticated principal. Call ONLY with an id the gateway has
+ * already authenticated (session token, mTLS identity, …). Passing a raw
+ * user-supplied string here is a principal-impersonation vulnerability.
+ */
+export function createAuthenticatedPrincipal(id, kind = 'user') {
+    if (typeof id !== 'string' || id.length === 0 || id.length > 256) {
+        throw new Error('createAuthenticatedPrincipal: invalid principal id');
+    }
+    return Object.freeze({ id, kind });
+}
+/** Attach a provenance label. Labels are the only trust signal — never inferred. */
+export function labelData(value, source, zone) {
+    return Object.freeze({ value, source, zone });
+}
+/** True only for operator config inside the gateway zone. */
+export function isTrustedData(data) {
+    return data.source === 'config' && data.zone === 'gateway';
+}
+/**
+ * Deterministic policy for zone crossings.
+ *
+ * - gateway → anywhere: allow (trusted decisions flow outward).
+ * - external/execution → gateway, kind='control': DENY. Untrusted zones
+ *   never issue control decisions; they only submit data for validation.
+ * - external/execution → gateway, kind='data': allow ONLY when the data
+ *   carries an explicit untrusted label — the gateway must validate it
+ *   (schema, bounds, sanitization) before use. The label is preserved.
+ * - execution → external: allow (egress), but the host should apply
+ *   egress filtering (secret redaction) — see audit.ts.
+ */
+export function evaluateCrossing(crossing) {
+    if (crossing.from === 'gateway') {
+        return { verdict: 'allow', reason: 'trusted zone decisions flow outward' };
+    }
+    if (crossing.to === 'gateway' && crossing.kind === 'control') {
+        return {
+            verdict: 'deny',
+            reason: `untrusted zone '${crossing.from}' cannot issue control decisions to the gateway`,
+        };
+    }
+    if (crossing.to === 'gateway' && crossing.kind === 'data') {
+        if (crossing.source === undefined) {
+            return { verdict: 'deny', reason: 'unlabeled data cannot enter the gateway' };
+        }
+        return {
+            verdict: 'allow',
+            reason: `untrusted data (${crossing.source}) admitted for validation; label preserved`,
+        };
+    }
+    // execution ↔ external traffic (egress / tool I/O): allowed, filtered elsewhere.
+    return { verdict: 'allow', reason: 'non-gateway traffic; egress filtering applies' };
+}
+/**
+ * Assert that a value is trusted before using it in a security decision
+ * (policy evaluation, authZ, command routing). Throws otherwise.
+ */
+export function assertTrusted(data, context) {
+    if (!isTrustedData(data)) {
+        throw new Error(`trust boundary violation [${context}]: ` +
+            `untrusted data (source=${data.source}, zone=${data.zone}) used in a security decision`);
+    }
+    return data.value;
+}

package/dist/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@theowlops/boombot",
+  "version": "1.1.1",
+  "type": "module"
+}

package/dist/proto/agent_core.proto

@@ -0,0 +1,56 @@
+syntax = "proto3";
+
+package boombot.agent.v1;
+
+service AgentCore {
+  rpc Health(HealthRequest) returns (HealthResponse);
+  rpc RunTurn(stream TurnFrame) returns (stream TurnFrame);
+}
+
+message HealthRequest {}
+
+message HealthResponse {
+  string status = 1;
+  string runtime = 2;
+}
+
+message TurnFrame {
+  string turn_id = 1;
+  string request_id = 2;
+  oneof body {
+    StartTurn start = 10;
+    CallbackRequest callback_request = 11;
+    CallbackResponse callback_response = 12;
+    AgentEvent event = 13;
+    TurnResult result = 14;
+    CancelTurn cancel = 15;
+  }
+}
+
+message StartTurn {
+  bytes context_json = 1;
+}
+
+message CallbackRequest {
+  string method = 1;
+  bytes payload_json = 2;
+  bool streaming = 3;
+}
+
+message CallbackResponse {
+  bytes payload_json = 1;
+  bool end = 2;
+  string error = 3;
+}
+
+message AgentEvent {
+  bytes event_json = 1;
+}
+
+message TurnResult {
+  bytes result_json = 1;
+}
+
+message CancelTurn {
+  string reason = 1;
+}

package/dist/python/agent-core-python/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "boombot-agent-core"
+version = "0.1.0"
+description = "BoomBot ML, Embedding & SFT Training Engine"
+requires-python = ">=3.11"
+dependencies = [
+  "grpcio>=1.81,<2",
+  "protobuf>=6.33,<7",
+]
+
+[project.scripts]
+boombot-train = "boombot_ml.training:main"
+boombot-embed = "boombot_ml.embeddings:main"
+
+[dependency-groups]
+ml = [
+  "torch>=2.0.0",
+  "transformers>=4.40.0",
+  "datasets>=2.18.0",
+  "peft>=0.10.0",
+  "sentence-transformers>=3.0.0",
+]
+dev = [
+  "grpcio-tools>=1.81,<2",
+  "pytest>=9,<10",
+  "ruff>=0.14,<0.15",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/boombot_agent", "src/boombot_ml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+exclude = ["src/boombot_agent/generated"]

package/dist/python/agent-core-python/src/boombot_agent/__init__.py

@@ -0,0 +1,5 @@
+"""BoomBot Python cognitive core."""
+
+from .turn import run_turn
+
+__all__ = ["run_turn"]

package/dist/python/agent-core-python/src/boombot_agent/generated/agent_core_pb2.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: agent_core.proto
+# Protobuf Python Version: 6.33.5
+"""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,
+    6,
+    33,
+    5,
+    '',
+    'agent_core.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10\x61gent_core.proto\x12\x10\x62oombot.agent.v1\"\x0f\n\rHealthRequest\"1\n\x0eHealthResponse\x12\x0e\n\x06status\x18\x01 \x01(\t\x12\x0f\n\x07runtime\x18\x02 \x01(\t\"\xf5\x02\n\tTurnFrame\x12\x0f\n\x07turn_id\x18\x01 \x01(\t\x12\x12\n\nrequest_id\x18\x02 \x01(\t\x12,\n\x05start\x18\n \x01(\x0b\x32\x1b.boombot.agent.v1.StartTurnH\x00\x12=\n\x10\x63\x61llback_request\x18\x0b \x01(\x0b\x32!.boombot.agent.v1.CallbackRequestH\x00\x12?\n\x11\x63\x61llback_response\x18\x0c \x01(\x0b\x32\".boombot.agent.v1.CallbackResponseH\x00\x12-\n\x05\x65vent\x18\r \x01(\x0b\x32\x1c.boombot.agent.v1.AgentEventH\x00\x12.\n\x06result\x18\x0e \x01(\x0b\x32\x1c.boombot.agent.v1.TurnResultH\x00\x12.\n\x06\x63\x61ncel\x18\x0f \x01(\x0b\x32\x1c.boombot.agent.v1.CancelTurnH\x00\x42\x06\n\x04\x62ody\"!\n\tStartTurn\x12\x14\n\x0c\x63ontext_json\x18\x01 \x01(\x0c\"J\n\x0f\x43\x61llbackRequest\x12\x0e\n\x06method\x18\x01 \x01(\t\x12\x14\n\x0cpayload_json\x18\x02 \x01(\x0c\x12\x11\n\tstreaming\x18\x03 \x01(\x08\"D\n\x10\x43\x61llbackResponse\x12\x14\n\x0cpayload_json\x18\x01 \x01(\x0c\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x08\x12\r\n\x05\x65rror\x18\x03 \x01(\t\" \n\nAgentEvent\x12\x12\n\nevent_json\x18\x01 \x01(\x0c\"!\n\nTurnResult\x12\x13\n\x0bresult_json\x18\x01 \x01(\x0c\"\x1c\n\nCancelTurn\x12\x0e\n\x06reason\x18\x01 \x01(\t2\xa1\x01\n\tAgentCore\x12K\n\x06Health\x12\x1f.boombot.agent.v1.HealthRequest\x1a .boombot.agent.v1.HealthResponse\x12G\n\x07RunTurn\x12\x1b.boombot.agent.v1.TurnFrame\x1a\x1b.boombot.agent.v1.TurnFrame(\x01\x30\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'agent_core_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_HEALTHREQUEST']._serialized_start=38
+  _globals['_HEALTHREQUEST']._serialized_end=53
+  _globals['_HEALTHRESPONSE']._serialized_start=55
+  _globals['_HEALTHRESPONSE']._serialized_end=104
+  _globals['_TURNFRAME']._serialized_start=107
+  _globals['_TURNFRAME']._serialized_end=480
+  _globals['_STARTTURN']._serialized_start=482
+  _globals['_STARTTURN']._serialized_end=515
+  _globals['_CALLBACKREQUEST']._serialized_start=517
+  _globals['_CALLBACKREQUEST']._serialized_end=591
+  _globals['_CALLBACKRESPONSE']._serialized_start=593
+  _globals['_CALLBACKRESPONSE']._serialized_end=661
+  _globals['_AGENTEVENT']._serialized_start=663
+  _globals['_AGENTEVENT']._serialized_end=695
+  _globals['_TURNRESULT']._serialized_start=697
+  _globals['_TURNRESULT']._serialized_end=730
+  _globals['_CANCELTURN']._serialized_start=732
+  _globals['_CANCELTURN']._serialized_end=760
+  _globals['_AGENTCORE']._serialized_start=763
+  _globals['_AGENTCORE']._serialized_end=924
+# @@protoc_insertion_point(module_scope)

package/dist/python/agent-core-python/src/boombot_agent/generated/agent_core_pb2_grpc.py

@@ -0,0 +1,140 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from . import agent_core_pb2 as agent__core__pb2
+
+GRPC_GENERATED_VERSION = '1.81.1'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in agent_core_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class AgentCoreStub:
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Health = channel.unary_unary(
+                '/boombot.agent.v1.AgentCore/Health',
+                request_serializer=agent__core__pb2.HealthRequest.SerializeToString,
+                response_deserializer=agent__core__pb2.HealthResponse.FromString,
+                _registered_method=True)
+        self.RunTurn = channel.stream_stream(
+                '/boombot.agent.v1.AgentCore/RunTurn',
+                request_serializer=agent__core__pb2.TurnFrame.SerializeToString,
+                response_deserializer=agent__core__pb2.TurnFrame.FromString,
+                _registered_method=True)
+
+
+class AgentCoreServicer:
+    """Missing associated documentation comment in .proto file."""
+
+    def Health(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def RunTurn(self, request_iterator, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_AgentCoreServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Health': grpc.unary_unary_rpc_method_handler(
+                    servicer.Health,
+                    request_deserializer=agent__core__pb2.HealthRequest.FromString,
+                    response_serializer=agent__core__pb2.HealthResponse.SerializeToString,
+            ),
+            'RunTurn': grpc.stream_stream_rpc_method_handler(
+                    servicer.RunTurn,
+                    request_deserializer=agent__core__pb2.TurnFrame.FromString,
+                    response_serializer=agent__core__pb2.TurnFrame.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'boombot.agent.v1.AgentCore', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('boombot.agent.v1.AgentCore', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class AgentCore:
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def Health(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/boombot.agent.v1.AgentCore/Health',
+            agent__core__pb2.HealthRequest.SerializeToString,
+            agent__core__pb2.HealthResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def RunTurn(request_iterator,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.stream_stream(
+            request_iterator,
+            target,
+            '/boombot.agent.v1.AgentCore/RunTurn',
+            agent__core__pb2.TurnFrame.SerializeToString,
+            agent__core__pb2.TurnFrame.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)