cc-transcript 14.33.0__tar.gz → 14.33.1__tar.gz

{cc_transcript-14.33.0 → cc_transcript-14.33.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.33.0
+Version: 14.33.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{cc_transcript-14.33.0 → cc_transcript-14.33.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.33.0" # informational — releases stamp the version from the git tag
+version = "14.33.1" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-14.33.0 → cc_transcript-14.33.1}/rust/crates/core/src/snapshot.rs

@@ -1325,14 +1325,24 @@ impl NativeStore {
         context: &Value,
     ) -> Result<String, SnapshotError> {
         self.authority(context, None)?;
+        let definitions =
+            crate::toolcall::ToolRegistrySnapshot::specs_from_json(specs).map_err(invalid)?;
+        let fingerprint = crate::toolcall::ToolRegistrySnapshot::fingerprint_of(&definitions);
+        if self
+            .state
+            .lock()
+            .expect("snapshot state")
+            .registries
+            .contains_key(&fingerprint)
+        {
+            return Ok(fingerprint);
+        }
         let charge = crate::snapshot_memory::value_charge(specs);
         let reserve = (charge.owned_capacity_bytes + charge.opaque_dom_accounted_bytes)
             .saturating_mul(4)
             .saturating_add(64 * 1024);
         let mut reservation = self.reserve_projection(context, reserve)?;
-        let registry =
-            crate::toolcall::ToolRegistrySnapshot::from_specs_json(specs).map_err(invalid)?;
-        let fingerprint = registry.fingerprint().to_owned();
+        let registry = crate::toolcall::ToolRegistrySnapshot::from_specs(definitions);
         let allocations = registry.accounted_allocations();
         let bytes = allocations.iter().map(|(_, bytes)| *bytes).sum::<usize>()
             + allocations.capacity() * size_of::<(usize, usize)>()
@@ -11384,4 +11394,49 @@ mod tests {
         ));
         assert_eq!(state.transient_bytes, 0);
     }
+
+    #[test]
+    fn reregistering_an_interned_registry_reserves_nothing() {
+        let store = NativeStore::new(
+            &json!({"max_retained_bytes":8*1024*1024,"reserved_hook_accounted_bytes":8*1024*1024}),
+        )
+        .unwrap();
+        let hook = context("owner");
+        let mut review = hook.clone();
+        review.insert("admission", json!("review"));
+        let other_uid = json!({"claimant":"owner","admission":"hook","authority":{"kind":"user","effective_uid":"0"},"registry_generation":hook["registry_generation"]});
+        let specs = json!([{"name":"fetch","behaves_like":"Read","span_edit":null}]);
+        let reordered = json!([{"span_edit":null,"behaves_like":"Read","name":"fetch"}]);
+        let fingerprint = store.register_tool_registry(&specs, &hook).unwrap();
+        let registered = store.state.lock().unwrap().registries.len();
+        let first = Arc::clone(&store.state.lock().unwrap().registries[&fingerprint].snapshot);
+        assert_eq!(
+            store.register_tool_registry(&reordered, &review).unwrap(),
+            fingerprint
+        );
+        assert_eq!(
+            store
+                .register_tool_registry(&specs, &other_uid)
+                .unwrap_err()
+                .status,
+            Status::PermissionDenied
+        );
+        assert_eq!(
+            store
+                .register_tool_registry(
+                    &json!([{"name":"","behaves_like":"Read","span_edit":null}]),
+                    &hook
+                )
+                .unwrap_err()
+                .status,
+            Status::InvalidRequest
+        );
+        let state = store.state.lock().unwrap();
+        assert_eq!(state.registries.len(), registered);
+        assert!(Arc::ptr_eq(
+            &first,
+            &state.registries[&fingerprint].snapshot
+        ));
+        assert_eq!(state.transient_bytes, 0);
+    }
 }

{cc_transcript-14.33.0 → cc_transcript-14.33.1}/rust/crates/core/src/toolcall.rs

@@ -127,15 +127,21 @@ pub struct ToolRegistrySnapshot {
 
 impl ToolRegistrySnapshot {
     pub fn from_specs(specs: HashMap<String, McpToolSpec>) -> Arc<Self> {
-        let value = sonic_rs::to_value(&specs).expect("tool registry serialization");
+        let fingerprint = Self::fingerprint_of(&specs);
+        Arc::new(Self { specs, fingerprint })
+    }
+
+    pub fn fingerprint_of(specs: &HashMap<String, McpToolSpec>) -> String {
+        let value = sonic_rs::to_value(specs).expect("tool registry serialization");
         let canonical = crate::ids::canonical_json(&value).expect("tool registry canonicalization");
-        Arc::new(Self {
-            specs,
-            fingerprint: format!("{:x}", Sha256::digest(canonical.as_bytes())),
-        })
+        format!("{:x}", Sha256::digest(canonical.as_bytes()))
     }
 
     pub fn from_specs_json(value: &Value) -> Result<Arc<Self>, String> {
+        Ok(Self::from_specs(Self::specs_from_json(value)?))
+    }
+
+    pub fn specs_from_json(value: &Value) -> Result<HashMap<String, McpToolSpec>, String> {
         let definitions = value
             .as_array()
             .ok_or_else(|| "tool registry definitions must be a list".to_string())?;
@@ -163,20 +169,18 @@ impl ToolRegistrySnapshot {
         }
         let definitions: Vec<ToolRegistryDefinition> =
             sonic_rs::from_value(value).map_err(|error| error.to_string())?;
-        Ok(Self::from_specs(
-            definitions
-                .into_iter()
-                .map(|definition| {
-                    (
-                        definition.name,
-                        McpToolSpec {
-                            behaves_like: definition.behaves_like,
-                            span_edit: definition.span_edit,
-                        },
-                    )
-                })
-                .collect(),
-        ))
+        Ok(definitions
+            .into_iter()
+            .map(|definition| {
+                (
+                    definition.name,
+                    McpToolSpec {
+                        behaves_like: definition.behaves_like,
+                        span_edit: definition.span_edit,
+                    },
+                )
+            })
+            .collect())
     }
 
     pub fn capture_scoped() -> Option<Arc<Self>> {
@@ -2396,6 +2400,22 @@ mod tests {
         assert_eq!(first.fingerprint(), reordered.fingerprint());
         assert_ne!(first.fingerprint(), changed.fingerprint());
         assert_eq!(first.fingerprint().len(), 64);
+        for (raw, constructed) in [
+            (
+                r#"[{"name":"reader","behaves_like":"Read","span_edit":null},{"name":"writer","behaves_like":"Edit","span_edit":{"path":"file","content":"body","delete":null}}]"#,
+                &first,
+            ),
+            (
+                r#"[{"name":"reader","behaves_like":"Read","span_edit":null},{"name":"writer","behaves_like":"Edit","span_edit":{"path":"file","content":"changed","delete":null}}]"#,
+                &changed,
+            ),
+        ] {
+            let specs = ToolRegistrySnapshot::specs_from_json(&obj(raw)).unwrap();
+            assert_eq!(
+                ToolRegistrySnapshot::fingerprint_of(&specs),
+                constructed.fingerprint()
+            );
+        }
         assert_eq!(
             ToolRegistrySnapshot::from_specs_json(&obj("[]"))
                 .unwrap()