digitalkin 1.0.5.dev0__tar.gz → 1.0.5.dev3__tar.gz

{digitalkin-1.0.5.dev0 → digitalkin-1.0.5.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.5.dev0
+Version: 1.0.5.dev3
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -453,7 +453,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ag-ui-protocol==0.1.21.dev1787220377
-Requires-Dist: agentic-mesh-protocol==1.0.3.dev0
+Requires-Dist: agentic-mesh-protocol==1.0.2
 Requires-Dist: agno<3,>=2.8.0
 Requires-Dist: anyio>=4.13.0
 Requires-Dist: grpcio-health-checking==1.82.1

{digitalkin-1.0.5.dev0 → digitalkin-1.0.5.dev3}/examples/redis_demo/client.py

@@ -2,10 +2,11 @@
 """Demo client for the Gateway gRPC service with per-endpoint testing.
 
 Subcommands:
-    full      Full pipeline: StartStream → Stream → SendSignal
+    full      Full pipeline: StartStream → ConsumeStream → SendSignal
     start     StartStream only (unary)
-    consume   Stream on existing task (requires --task-id)
-    signal    SendSignal(cancel) on existing task (requires --task-id)
+    consume   ConsumeStream on existing task (requires --task-id)
+    produce   StartStream + ProduceStream (act as Module A)
+    signal    SendSignal on existing task (requires --task-id)
     inspect   Dump Redis keys for a task (no gRPC)
 
 Usage:
@@ -13,7 +14,8 @@ Usage:
     python client.py full --prompt "Test" --setup '{"uppercase": true, "repeat": 5}'
     python client.py start --prompt "Hello"
     python client.py consume --task-id <uuid>
-    python client.py signal --task-id <uuid>
+    python client.py produce --task-id <uuid> --chunks 3
+    python client.py signal --task-id <uuid> --action cancel
     python client.py inspect --task-id <uuid>
 """
 
@@ -32,7 +34,7 @@ import grpc
 import redis.asyncio as aioredis
 from google.protobuf import json_format, struct_pb2
 
-from agentic_mesh_protocol.gateway.v1 import gateway_dto_pb2, gateway_messages_pb2, gateway_service_pb2_grpc
+from agentic_mesh_protocol.gateway.v1 import gateway_pb2, gateway_service_pb2_grpc
 
 # ── ANSI colors ─────────────────────────────────────────────────────
 
@@ -289,18 +291,29 @@ def _print_diff_report(tracker: RedisTracker, task_id: str) -> None:
 async def cmd_start(
     stub: gateway_service_pb2_grpc.GatewayServiceStub,
     task_id: str,
+    prompt: str,
+    setup: dict[str, Any] | None,
 ) -> bool:
     """StartStream — create a task session.
 
     Returns:
         True if accepted.
     """
+    input_struct = struct_pb2.Struct()
+    payload: dict[str, Any] = {
+        "root": {"protocol": "message", "text": prompt},
+    }
+    if setup:
+        payload["setup"] = setup
+    input_struct.update(payload)
+
     t0 = time.monotonic()
     resp = await stub.StartStream(
-        gateway_dto_pb2.StartStreamRequest(
+        gateway_pb2.StartStreamRequest(
             task_id=task_id,
-            setup_id="setups:demo",
-            mission_id="missions:demo",
+            input=input_struct,
+            setup_id="demo-setup",
+            mission_id="demo-mission",
         ),
     )
     elapsed = (time.monotonic() - t0) * 1000
@@ -314,58 +327,112 @@ async def cmd_start(
 async def cmd_consume(
     stub: gateway_service_pb2_grpc.GatewayServiceStub,
     task_id: str,
-        prompt: str,
-        setup: dict[str, Any] | None,
     verbose: bool,
 ) -> list[dict[str, Any]]:
-    """Stream — send the query, then read module output until ``stream.end``.
+    """ConsumeStream — read module output from Redis.
 
     Returns:
         List of received items.
     """
     received: list[dict[str, Any]] = []
-    query: dict[str, Any] = {"root": {"protocol": "message", "text": prompt}}
-    if setup:
-        query["setup"] = setup
-    query_struct = struct_pb2.Struct()
-    query_struct.update(query)
 
     async def _requests() -> AsyncGenerator:
-        yield gateway_messages_pb2.StreamRequest(task_id=task_id, from_seq=0, data=query_struct)
+        yield gateway_pb2.ConsumeStreamRequest(
+            init=gateway_pb2.ConsumeStreamInit(task_id=task_id, from_seq=0),
+        )
 
     t0 = time.monotonic()
-    async for resp in stub.Stream(_requests()):
-        root = json_format.MessageToDict(resp.data).get("root", {})
-        protocol = root.get("protocol", "")
-        if protocol == "stream.error":
-            received.append({"seq": resp.seq, "error": root.get("message", "")})
-            print(f"  {RED}error: code={root.get('code')} msg={root.get('message')}{RESET}")  # noqa: T201
-            continue
-        if protocol == "stream.end":
-            received.append({"seq": resp.seq, "status": "stream.end"})
-            print(f"  {GREEN}stream.end{RESET}  ({(time.monotonic() - t0) * 1000:.1f}ms total)")  # noqa: T201
+    resp_stream = stub.ConsumeStream(_requests())
+    async for resp in resp_stream:
+        elapsed = (time.monotonic() - t0) * 1000
+        payload_type = resp.WhichOneof("payload")
+
+        if payload_type == "output":
+            data_dict = json_format.MessageToDict(resp.output.data)
+            text = data_dict.get("root", {}).get("text", data_dict.get("root", {}).get("protocol", ""))
+            received.append({"seq": resp.output.seq, "text": text})
+            print(f"  {GREEN}seq={resp.output.seq:>2}{RESET}  {text}")  # noqa: T201
+            if verbose:
+                print(f"         {DIM}{json.dumps(data_dict, ensure_ascii=False)}{RESET}")  # noqa: T201
+
+        elif payload_type == "status":
+            state_name = gateway_pb2.StreamState.Name(resp.status.state)
+            received.append({"status": state_name})
+            color = GREEN if "COMPLETED" in state_name else YELLOW
+            print(f"  {color}status: {state_name}{RESET}  ({elapsed:.1f}ms total)")  # noqa: T201
             break
-        text = root.get("text", protocol)
-        received.append({"seq": resp.seq, "text": text})
-        print(f"  {GREEN}seq={resp.seq:>2}{RESET}  {text}")  # noqa: T201
-        if verbose:
-            print(f"         {DIM}{json.dumps(root, ensure_ascii=False)}{RESET}")  # noqa: T201
+
+        elif payload_type == "error":
+            received.append({"error": resp.error.message})
+            print(f"  {RED}error: code={resp.error.code} msg={resp.error.message}{RESET}")  # noqa: T201
+            break
+
+        elif payload_type == "heartbeat":
+            if verbose:
+                print(f"  {DIM}heartbeat{RESET}")  # noqa: T201
 
     return received
 
 
+async def cmd_produce(
+    stub: gateway_service_pb2_grpc.GatewayServiceStub,
+    task_id: str,
+    prompt: str,
+    num_chunks: int,
+) -> int:
+    """ProduceStream — act as Module A, push output chunks.
+
+    Returns:
+        Number of server responses.
+    """
+    async def _requests() -> AsyncGenerator:
+        yield gateway_pb2.ProduceStreamRequest(
+            init=gateway_pb2.ProduceStreamInit(task_id=task_id),
+        )
+        for i in range(num_chunks):
+            data = struct_pb2.Struct()
+            data.update({
+                "root": {
+                    "protocol": "message",
+                    "text": f"[{i + 1}/{num_chunks}] {prompt}",
+                },
+            })
+            yield gateway_pb2.ProduceStreamRequest(
+                output=gateway_pb2.ProduceStreamOutput(task_id=task_id, data=data),
+            )
+            await asyncio.sleep(0.05)
+
+    t0 = time.monotonic()
+    resp_stream = stub.ProduceStream(_requests())
+    count = 0
+    async for resp in resp_stream:
+        count += 1
+        payload = resp.WhichOneof("payload")
+        print(f"  response #{count}: {payload}")  # noqa: T201
+
+    elapsed = (time.monotonic() - t0) * 1000
+    print(f"  {DIM}stream closed ({count} responses, {elapsed:.1f}ms){RESET}")  # noqa: T201
+    return count
+
+
 async def cmd_signal(
     stub: gateway_service_pb2_grpc.GatewayServiceStub,
     task_id: str,
+    action: str,
 ) -> bool:
-    """SendSignal — cancel a running task.
+    """SendSignal — send a control signal.
 
     Returns:
         True if accepted.
     """
+    action_enum = (
+        gateway_pb2.SIGNAL_ACTION_CANCEL if action == "cancel"
+        else gateway_pb2.SIGNAL_ACTION_PAUSE
+    )
+
     t0 = time.monotonic()
     resp = await stub.SendSignal(
-        gateway_dto_pb2.SendSignalRequest(cancel=gateway_messages_pb2.CancelSignal(task_id=task_id)),
+        gateway_pb2.ClientSignalRequest(task_id=task_id, action=action_enum),
     )
     elapsed = (time.monotonic() - t0) * 1000
 
@@ -380,7 +447,7 @@ async def cmd_signal(
 
 
 async def run_full(args: argparse.Namespace) -> None:
-    """Full pipeline: StartStream → Stream → SendSignal."""
+    """Full pipeline: StartStream → ConsumeStream → SendSignal."""
     task_id = args.task_id or str(uuid.uuid4())
     setup = json.loads(args.setup) if args.setup else None
     tracker = RedisTracker(args.redis) if args.verbose else None
@@ -400,7 +467,7 @@ async def run_full(args: argparse.Namespace) -> None:
 
             # 1. StartStream
             print(f"\n{BOLD}[1] StartStream{RESET}")  # noqa: T201
-            accepted = await cmd_start(stub, task_id)
+            accepted = await cmd_start(stub, task_id, args.prompt, setup)
             if not accepted:
                 print(f"  {RED}Server rejected the task — aborting.{RESET}")  # noqa: T201
                 return
@@ -409,17 +476,18 @@ async def run_full(args: argparse.Namespace) -> None:
                 await asyncio.sleep(0.1)
                 await tracker.snapshot("StartStream", task_id)
 
-            # 2. Stream — send the query, read module output
-            print(f"\n{BOLD}[2] Stream{RESET}")  # noqa: T201
-            received = await cmd_consume(stub, task_id, args.prompt, setup, args.verbose)
+            # 2. ConsumeStream — wait for module output
+            print(f"\n{BOLD}[2] ConsumeStream{RESET}")  # noqa: T201
+            await asyncio.sleep(0.2)  # let module start
+            received = await cmd_consume(stub, task_id, args.verbose)
 
             if tracker:
                 await asyncio.sleep(0.1)
-                await tracker.snapshot("Stream", task_id)
+                await tracker.snapshot("ConsumeStream", task_id)
 
             # 3. SendSignal
             print(f"\n{BOLD}[3] SendSignal (cancel){RESET}")  # noqa: T201
-            await cmd_signal(stub, task_id)
+            await cmd_signal(stub, task_id, "cancel")
 
             if tracker:
                 await asyncio.sleep(0.1)
@@ -445,39 +513,61 @@ async def run_full(args: argparse.Namespace) -> None:
 async def run_start(args: argparse.Namespace) -> None:
     """StartStream only."""
     task_id = args.task_id or str(uuid.uuid4())
+    setup = json.loads(args.setup) if args.setup else None
 
     print(f"\n{BOLD}[StartStream]{RESET}  gateway={args.gateway}  task_id={task_id}")  # noqa: T201
 
     async with grpc.aio.insecure_channel(args.gateway, options=GRPC_OPTIONS) as channel:
         stub = gateway_service_pb2_grpc.GatewayServiceStub(channel)
-        await cmd_start(stub, task_id)
+        await cmd_start(stub, task_id, args.prompt, setup)
 
 
 async def run_consume(args: argparse.Namespace) -> None:
-    """Stream on existing task."""
+    """ConsumeStream on existing task."""
     if not args.task_id:
         print(f"{RED}--task-id is required for consume{RESET}")  # noqa: T201
         sys.exit(1)
 
+    print(f"\n{BOLD}[ConsumeStream]{RESET}  gateway={args.gateway}  task_id={args.task_id}")  # noqa: T201
+
+    async with grpc.aio.insecure_channel(args.gateway, options=GRPC_OPTIONS) as channel:
+        stub = gateway_service_pb2_grpc.GatewayServiceStub(channel)
+        await cmd_consume(stub, args.task_id, args.verbose)
+
+
+async def run_produce(args: argparse.Namespace) -> None:
+    """StartStream + ProduceStream (act as Module A)."""
+    task_id = args.task_id or str(uuid.uuid4())
     setup = json.loads(args.setup) if args.setup else None
-    print(f"\n{BOLD}[Stream]{RESET}  gateway={args.gateway}  task_id={args.task_id}")  # noqa: T201
+
+    print(f"\n{BOLD}[Produce]{RESET}  gateway={args.gateway}  task_id={task_id}")  # noqa: T201
 
     async with grpc.aio.insecure_channel(args.gateway, options=GRPC_OPTIONS) as channel:
         stub = gateway_service_pb2_grpc.GatewayServiceStub(channel)
-        await cmd_consume(stub, args.task_id, args.prompt, setup, args.verbose)
+
+        # StartStream first (registers the session)
+        print(f"\n  {BOLD}StartStream{RESET}")  # noqa: T201
+        accepted = await cmd_start(stub, task_id, args.prompt, setup)
+        if not accepted:
+            print(f"  {RED}Rejected{RESET}")  # noqa: T201
+            return
+
+        # ProduceStream (act as Module A)
+        print(f"\n  {BOLD}ProduceStream ({args.chunks} chunks){RESET}")  # noqa: T201
+        await cmd_produce(stub, task_id, args.prompt, args.chunks)
 
 
 async def run_signal(args: argparse.Namespace) -> None:
-    """SendSignal(cancel) on existing task."""
+    """SendSignal on existing task."""
     if not args.task_id:
         print(f"{RED}--task-id is required for signal{RESET}")  # noqa: T201
         sys.exit(1)
 
-    print(f"\n{BOLD}[SendSignal]{RESET}  gateway={args.gateway}  task_id={args.task_id}  signal=cancel")  # noqa: T201
+    print(f"\n{BOLD}[SendSignal]{RESET}  gateway={args.gateway}  task_id={args.task_id}  action={args.action}")  # noqa: T201
 
     async with grpc.aio.insecure_channel(args.gateway, options=GRPC_OPTIONS) as channel:
         stub = gateway_service_pb2_grpc.GatewayServiceStub(channel)
-        await cmd_signal(stub, args.task_id)
+        await cmd_signal(stub, args.task_id, args.action)
 
 
 async def run_inspect(args: argparse.Namespace) -> None:
@@ -523,7 +613,8 @@ examples:
   %(prog)s full --prompt "Test" --setup '{"uppercase": true, "repeat": 5}'
   %(prog)s start --prompt "Hello"
   %(prog)s consume --task-id <uuid>
-  %(prog)s signal --task-id <uuid>
+  %(prog)s produce --chunks 5 --prompt "Manual"
+  %(prog)s signal --task-id <uuid> --action cancel
   %(prog)s inspect --task-id <uuid>
 """,
     )
@@ -540,16 +631,21 @@ examples:
     sub = p.add_subparsers(dest="command", help="Endpoint to test")
 
     # full (default)
-    sub.add_parser("full", help="Full pipeline: StartStream -> Stream -> SendSignal")
+    sub.add_parser("full", help="Full pipeline: StartStream -> ConsumeStream -> SendSignal")
 
     # start
     sub.add_parser("start", help="StartStream only (unary)")
 
     # consume
-    sub.add_parser("consume", help="Stream on existing task (requires --task-id)")
+    sub.add_parser("consume", help="ConsumeStream on existing task (requires --task-id)")
+
+    # produce
+    sp_produce = sub.add_parser("produce", help="StartStream + ProduceStream (act as Module A)")
+    sp_produce.add_argument("--chunks", type=int, default=3, help="Number of chunks to produce (default: 3)")
 
     # signal
-    sub.add_parser("signal", help="SendSignal(cancel) on existing task (requires --task-id)")
+    sp_signal = sub.add_parser("signal", help="SendSignal on existing task (requires --task-id)")
+    sp_signal.add_argument("--action", choices=["cancel", "pause"], default="cancel", help="Signal action (default: cancel)")
 
     # inspect
     sub.add_parser("inspect", help="Dump Redis keys for a task (no gRPC)")
@@ -566,10 +662,17 @@ async def main() -> None:
     if not args.command:
         args.command = "full"
 
+    # Set defaults for subcommand-specific args
+    if not hasattr(args, "chunks"):
+        args.chunks = 3
+    if not hasattr(args, "action"):
+        args.action = "cancel"
+
     handlers = {
         "full": run_full,
         "start": run_start,
         "consume": run_consume,
+        "produce": run_produce,
         "signal": run_signal,
         "inspect": run_inspect,
     }

{digitalkin-1.0.5.dev0 → digitalkin-1.0.5.dev3}/examples/services/filesystem_module.py

@@ -10,7 +10,8 @@ from pydantic import BaseModel, Field
 from digitalkin.logger import logger
 from digitalkin.models.module import ModuleStatus
 from digitalkin.modules.archetype_module import ArchetypeModule
-from digitalkin.services.filesystem.filesystem_strategy import FileFilter, UploadFileData
+from digitalkin.models.services.filesystem import FileType
+from digitalkin.services.filesystem import FileFilter, UploadFileData
 from digitalkin.services.services_config import ServicesConfig
 from digitalkin.services.services_models import ServicesMode
 
@@ -118,9 +119,9 @@ class ExampleModule(ArchetypeModule[ExampleInput, ExampleOutput, ExampleSetup, E
         file = UploadFileData(
             content=b"%s\n%s" % (processed_message.encode(), str(processed_number).encode()),
             name="example_output.txt",
-            file_type="text/plain",
+            type=FileType.DOCUMENT,
             content_type="text/plain",
-            metadata={"example_key": "example_value"},
+            metadata={"sdk_created": True},
             replace_if_exists=True,
         )
 
@@ -176,10 +177,10 @@ async def test_module() -> None:
     # Check the storage
     if module.status == ModuleStatus.STOPPED:
         files, _nb_results = await module.filesystem.get_files(
-            filters=FileFilter(name="example_output.txt", context="test-mission-123"),
+            filters=FileFilter(names=["example_output.txt"]),
         )
         for file in files:
-            await module.filesystem.update_file(file.id, file_type="updated")
+            await module.filesystem.update_file(file.id, type=FileType.OTHER)
             # module.filesystem.delete_files(filters=FileFilter(name="example_output.txt", context="test-mission-123"), permanent=True)
 
             logger.info("Retrieved file: %s with ID: %s", file.name, file.id)
@@ -188,7 +189,7 @@ async def test_module() -> None:
                 if file_record:
                     logger.info("File ID: %s", file_record.id)
                     logger.info("File name: %s", file_record.name)
-                    logger.info("File type: %s", file_record.file_type)
+                    logger.info("File type: %s", file_record.type)
                     logger.info("File status: %s", file_record.status)
                     logger.info("File content: %s", file_record.content.decode())
             except Exception:

{digitalkin-1.0.5.dev0 → digitalkin-1.0.5.dev3}/pyproject.toml

@@ -31,7 +31,7 @@
         # which is how a nested run's output is attributed to its author. Pinned exactly
         # because it is a dated prerelease; move to >=0.1.21 once that ships stable.
         "ag-ui-protocol==0.1.21.dev1787220377",
-        "agentic-mesh-protocol==1.0.3.dev0",
+        "agentic-mesh-protocol==1.0.2",
         "agno>=2.8.0,<3",
         "anyio>=4.13.0",
         "grpcio-health-checking==1.82.1",
@@ -41,7 +41,7 @@
         "pydantic>=2.12.4",
         "redis[hiredis]>=7.4.0,<9",
     ]
-version = "1.0.5.dev0"
+    version = "1.0.5.dev3"
 
     [project.optional-dependencies]
         agno = [ "agno>=2.6" ]
@@ -208,15 +208,15 @@ version = "1.0.5.dev0"
         ]
 
         ignore = [
-            "ANN401",  # Allow typing.Any — gRPC stubs, callbacks, and dynamic APIs require it
-            "COM812",  # Disable because of formatter incompatibility
-            "DOC502",  # Allow extraneous-exception in docstring
-            "F401",    # Allow unused imports — used for availability checks
-            "N802",    # Allow PascalCase methods — gRPC servicer convention
-            "PLC0415", # Allow lazy imports — needed to break circular dependencies
-            "PLW3201", # Allow __get_pydantic_core_schema__ — Pydantic dunder hook
-            "S105",    # Hardcoded-password
-            "S403",    # Allow pickle import
+            "any-type",                       # Allow typing.Any — gRPC stubs, callbacks, and dynamic APIs require it
+            "missing-trailing-comma",         # Disable because of formatter incompatibility
+            "docstring-extraneous-exception", # Allow extraneous-exception in docstring
+            "unused-import",                  # Allow unused imports — used for availability checks
+            "invalid-function-name",          # Allow PascalCase methods — gRPC servicer convention
+            "import-outside-top-level",       # Allow lazy imports — needed to break circular dependencies
+            "bad-dunder-method-name",         # Allow __get_pydantic_core_schema__ — Pydantic dunder hook
+            "hardcoded-password-string",      # Hardcoded-password
+            "suspicious-pickle-import",       # Allow pickle import
         ]
 
         fixable = [ "ALL" ]
@@ -226,40 +226,40 @@ version = "1.0.5.dev0"
 
         [tool.ruff.lint.per-file-ignores]
             "tests/**/*.py" = [
-                "ANN001",
-                "ANN002",
-                "ANN003",
-                "ANN201",
-                "ANN401",
-                "ARG001",
-                "ARG002",
-                "C901",
-                "D100",
-                "D101",
-                "D102",
-                "D103",
-                "D107",
-                "D417",
-                "DOC201",
-                "DOC501",
-                "E501",
-                "ERA001",
-                "FBT001",
-                "FBT002",
-                "G004",
-                "N802",
-                "PERF203",
-                "PLC2701",
-                "PLR0911",
-                "PLR0912",
-                "PLR0914",
-                "PLR0915",
-                "PLR1702",
-                "PLR2004",
-                "PLR6301",
-                "S101",
-                "SLF001",
-                "TRY002",
+                "missing-type-function-argument",
+                "missing-type-args",
+                "missing-type-kwargs",
+                "missing-return-type-undocumented-public-function",
+                "any-type",
+                "unused-function-argument",
+                "unused-method-argument",
+                "complex-structure",
+                "undocumented-public-module",
+                "undocumented-public-class",
+                "undocumented-public-method",
+                "undocumented-public-function",
+                "undocumented-public-init",
+                "undocumented-param",
+                "docstring-missing-returns",
+                "docstring-missing-exception",
+                "line-too-long",
+                "commented-out-code",
+                "boolean-type-hint-positional-argument",
+                "boolean-default-value-positional-argument",
+                "logging-f-string",
+                "invalid-function-name",
+                "try-except-in-loop",
+                "import-private-name",
+                "too-many-return-statements",
+                "too-many-branches",
+                "too-many-locals",
+                "too-many-statements",
+                "too-many-nested-blocks",
+                "magic-value-comparison",
+                "no-self-use",
+                "assert",
+                "private-member-access",
+                "raise-vanilla-class",
             ]
 
         [tool.ruff.lint.pylint]

{digitalkin-1.0.5.dev0 → digitalkin-1.0.5.dev3}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "1.0.5.dev0"
+    __version__ = "1.0.5.dev3"