deepstrike 0.2.42__tar.gz → 0.2.44__tar.gz

{deepstrike-0.2.42 → deepstrike-0.2.44}/Cargo.lock

@@ -194,7 +194,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.42"
+version = "0.2.44"
 dependencies = [
  "compact_str",
  "pretty_assertions",
@@ -206,7 +206,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-lab"
-version = "0.2.42"
+version = "0.2.44"
 dependencies = [
  "deepstrike-core",
  "serde",
@@ -216,7 +216,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.42"
+version = "0.2.44"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -228,7 +228,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.42"
+version = "0.2.44"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -239,7 +239,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.42"
+version = "0.2.44"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -273,7 +273,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.42"
+version = "0.2.44"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.42 → deepstrike-0.2.44}/Cargo.toml

@@ -3,13 +3,13 @@ resolver = "2"
 members = ["crates/deepstrike-core", "crates/deepstrike-py"]
 
 [workspace.package]
-version = "0.2.42"
+version = "0.2.44"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/kongusen/deepstrike"
 
 [workspace.dependencies]
-deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.42" }
+deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.44" }
 notify = "6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

{deepstrike-0.2.42 → deepstrike-0.2.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.42
+Version: 0.2.44
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0

{deepstrike-0.2.42 → deepstrike-0.2.44}/crates/deepstrike-core/src/runtime/kernel/protocol.rs

@@ -92,6 +92,13 @@ pub struct KernelInput {
 }
 
 impl KernelInput {
+    /// Operation identity used by [`Self::new`] for in-process callers. Hosts that correlate
+    /// against it (e.g. a `cancel_operation` for an operation started via `new`) must use this
+    /// constant, never a re-typed literal. NOT for durable wire hosts: anything keyed by
+    /// `(session, operation)` in storage that outlives the process needs a unique identity via
+    /// [`Self::correlated`].
+    pub const LOCAL_OPERATION_ID: &'static str = "local-operation";
+
     /// Build an in-process input for callers that do not cross a durable wire boundary.
     /// Wire hosts should use [`Self::correlated`] with their durable identities.
     pub fn new(event: KernelInputEvent) -> Self {
@@ -99,7 +106,7 @@ impl KernelInput {
         static LOCAL_EVENT_SEQUENCE: AtomicU64 = AtomicU64::new(1);
         let event_seq = LOCAL_EVENT_SEQUENCE.fetch_add(1, Ordering::Relaxed);
         Self::correlated(
-            "local-operation",
+            Self::LOCAL_OPERATION_ID,
             format!("local-event-{event_seq}"),
             0,
             event,

{deepstrike-0.2.42 → deepstrike-0.2.44}/crates/deepstrike-py/src/lib.rs

@@ -860,7 +860,10 @@ impl RenderedContext {
 
 // ──────────────────────────────────────── KernelRuntime ────────────────────────────────────
 
-#[pyclass]
+// `weakref` so the SDK can key per-runtime wire state in a WeakKeyDictionary — a module dict
+// keyed by id() aliases recycled addresses (a new runtime inherits a dead one's operation
+// identity) and leaks an entry per runtime.
+#[pyclass(weakref)]
 struct KernelRuntime {
     inner: RustKernelRuntime,
 }

{deepstrike-0.2.42 → deepstrike-0.2.44}/deepstrike/harness/harness.py

@@ -45,6 +45,10 @@ class AttemptRequest:
     goal: str
     session_id: str | None = None
     criteria: list[Criterion] = field(default_factory=list)
+    # Multimodal inputs (images / audio) attached to the task. Forwarded to every attempt
+    # unconditionally; the runner seeds them per session idempotently, so fresh-session
+    # carries re-seed while same-session carries do not double.
+    attachments: list[dict] | None = None
     extensions: dict[str, Any] | None = None
     inherit_events: list[Any] | None = None
 
@@ -57,6 +61,7 @@ class AttemptBodyContext:
     extensions: dict[str, Any] | None
     inherit_events: list[Any] | None
     attempt: int
+    attachments: list[dict] | None = None
     context_input: str | None = None
 
 
@@ -102,6 +107,7 @@ class RuntimeAttemptBody:
                 session_id=context.session_id,
                 goal=context.goal,
                 criteria=[criterion.text for criterion in context.criteria],
+                **({"attachments": context.attachments} if context.attachments else {}),
                 extensions=context.extensions,
                 inherit_events=context.inherit_events if context.attempt == 1 else None,
             )
@@ -294,6 +300,7 @@ class AttemptLoop:
                     extensions=request.extensions,
                     inherit_events=request.inherit_events,
                     attempt=attempt,
+                    attachments=request.attachments,
                     context_input=prepared.context_input,
                 )
             ):

{deepstrike-0.2.42 → deepstrike-0.2.44}/deepstrike/runtime/kernel_step.py

@@ -4,6 +4,7 @@ import json
 import re
 import time
 import uuid
+import weakref
 from dataclasses import dataclass
 from types import SimpleNamespace
 from typing import Any
@@ -13,7 +14,11 @@ from deepstrike.providers.base import ContextBudgetOverflow, RenderedContext
 
 
 KERNEL_ABI_VERSION = 2
-_wire_states: dict[int, tuple[str, int]] = {}
+# Keyed by the runtime OBJECT, not id(runtime): a plain dict keyed by id() aliases recycled
+# addresses (a new runtime inherits a dead one's operation identity — fatal once a durable log
+# keys chains by that identity) and leaks an entry per runtime. WeakKeyDictionary mirrors the
+# Node/WASM WeakMap; the pyo3 KernelRuntime declares `weakref` support for exactly this.
+_wire_states: "weakref.WeakKeyDictionary[Any, tuple[str, int]]" = weakref.WeakKeyDictionary()
 
 
 def snapshot_kernel_runtime(runtime: Any) -> dict[str, Any]:
@@ -24,14 +29,14 @@ def restore_kernel_runtime(runtime: Any, snapshot: dict[str, Any]) -> None:
   runtime.restore(json.dumps(snapshot))
   operation_id = snapshot.get("operation_id")
   if not operation_id:
-    _wire_states.pop(id(runtime), None)
+    _wire_states.pop(runtime, None)
     return
   next_sequence = 1
   for accepted in snapshot.get("accepted_inputs") or []:
     match = re.search(r"-event-(\d+)$", str(accepted.get("event_id") or ""))
     if match:
       next_sequence = max(next_sequence, int(match.group(1)) + 1)
-  _wire_states[id(runtime)] = (str(operation_id), next_sequence)
+  _wire_states[runtime] = (str(operation_id), next_sequence)
 
 
 @dataclass
@@ -373,12 +378,11 @@ def _action_from_kernel(raw: dict[str, Any]) -> KernelRunnerAction:
 
 
 def _step_input(runtime: Any, event: dict[str, Any]) -> str:
-  key = id(runtime)
-  state = _wire_states.get(key)
+  state = _wire_states.get(runtime)
   if state is None:
     state = (f"python-operation-{uuid.uuid4()}", 1)
   operation_id, sequence = state
-  _wire_states[key] = (operation_id, sequence + 1)
+  _wire_states[runtime] = (operation_id, sequence + 1)
   correlated_event = (
     {**event, "operation_id": operation_id}
     if event.get("kind") == "cancel_operation"

{deepstrike-0.2.42 → deepstrike-0.2.44}/deepstrike/runtime/large_result_spool.py

@@ -16,9 +16,16 @@ class LargeResultSpool:
     self._max_age_seconds = max_age_seconds
     self._active_writes: dict[str, asyncio.Lock] = {}
 
-  async def persist_output(self, call_id: str, content: str) -> str:
+  @staticmethod
+  def _call_key(session_id: str, call_id: str) -> str:
+    # Session-scoped: the spool dir is shared across sessions and outlives runs, while vendor
+    # call ids can be index-style ("call_0") and repeat — an unscoped key lets read_result in
+    # one session fetch another session's spooled output.
+    return hashlib.sha256(f"{session_id}\x00{call_id}".encode("utf-8")).hexdigest()[:32]
+
+  async def persist_output(self, session_id: str, call_id: str, content: str) -> str:
     digest = hashlib.sha256(content.encode("utf-8")).hexdigest()[:16]
-    call_key = hashlib.sha256(call_id.encode("utf-8")).hexdigest()[:32]
+    call_key = self._call_key(session_id, call_id)
     self._spool_dir.mkdir(parents=True, exist_ok=True)
     path = self._spool_dir / f"{call_key}-{digest}.txt"
     path_str = str(path)
@@ -50,16 +57,16 @@ class LargeResultSpool:
       return path.read_text(encoding="utf-8")
     return await asyncio.get_running_loop().run_in_executor(None, _read)
 
-  async def find_by_call_id(self, call_id: str) -> str | None:
+  async def find_by_call_id(self, session_id: str, call_id: str) -> str | None:
     """O7: locate a spooled output by the tool call's id (the ``read_result`` meta-tool only
     knows ``call_id``, not the content-hashed file name ``persist_output`` chose). Scans the
-    spool directory for the hashed call-key prefix; returns ``None`` if nothing
+    spool directory for the hashed session-scoped call-key prefix; returns ``None`` if nothing
     was ever spooled for that call."""
     if not self._spool_dir.is_dir():
       return None
 
     def _find() -> Path | None:
-      call_key = hashlib.sha256(call_id.encode("utf-8")).hexdigest()[:32]
+      call_key = self._call_key(session_id, call_id)
       matches = sorted(self._spool_dir.glob(f"{call_key}-*.txt"))
       return matches[0] if matches else None
 

{deepstrike-0.2.42 → deepstrike-0.2.44}/deepstrike/runtime/runner.py

@@ -1706,6 +1706,11 @@ class RuntimeRunner:
     mid_run = _is_mid_run(prior)
     resumed_start = next((entry for entry in reversed(prior) if entry.event.get("kind") == "run_started"), None)
     run_id = resumed_start.event["run_id"] if mid_run and resumed_start is not None else str(uuid.uuid4())
+    # Idempotent per session: an earlier run's `run_started` already carries these attachments
+    # (same-session retry attempt), so replay reconstructs them — recording and seeding again
+    # would double them in history. Deduping at the append keeps live and replay in agreement.
+    if attachments and _attachments_already_seeded(prior, attachments):
+      attachments = None
     if not mid_run:
       await self._opts.session_log.append(sid, {
         "kind": "run_started",
@@ -1859,7 +1864,7 @@ class RuntimeRunner:
     from deepstrike.runtime.large_result_spool import LargeResultSpool
     spool = self._opts.result_spool or LargeResultSpool()
     try:
-      full = await spool.find_by_call_id(call_id)
+      full = await spool.find_by_call_id(session_id, call_id)
     except Exception:
       full = None
 
@@ -2435,7 +2440,7 @@ class RuntimeRunner:
         spool_ref = None
         error = None
         try:
-          spool_ref = await spool.persist_output(action.call_id or "", action.output or "")
+          spool_ref = await spool.persist_output(session_id, action.call_id or "", action.output or "")
         except Exception as exc:
           error = format_tool_error(exc)
         action = kernel_action(runtime, self._pending_observations, {
@@ -3060,6 +3065,18 @@ def _is_mid_run(events: list[SessionEntry]) -> bool:
   return last_started >= 0 and last_started > last_terminal
 
 
+def _attachments_already_seeded(prior: list[SessionEntry], attachments: list[dict]) -> bool:
+  """True when an earlier run in this session already seeded the same attachments. Replay
+  reconstructs the attachment message from that run's ``run_started``, so recording and
+  live-seeding them again (a same-session retry attempt) would double them in history."""
+  wanted = json.dumps(attachments, sort_keys=True)
+  return any(
+    entry.event.get("kind") == "run_started"
+    and json.dumps(entry.event.get("attachments") or [], sort_keys=True) == wanted
+    for entry in prior
+  )
+
+
 def _normalize_attachment_parts(parts: list[dict]) -> list[dict]:
   """Normalize SDK attachment dicts to kernel serde shape (`media_type`, not `mediaType`)."""
   normalized: list[dict] = []

{deepstrike-0.2.42 → deepstrike-0.2.44}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "deepstrike"
-version = "0.2.42"
+version = "0.2.44"
 requires-python = ">=3.10"
 readme = "README.md"
 dependencies = [