cmpnd 0.83.0__tar.gz → 0.85.0__tar.gz

{cmpnd-0.83.0 → cmpnd-0.85.0}/AGENTS.md

@@ -137,7 +137,13 @@ still install against the `dspy>=…` floor in `dependencies`.
 - `scripts/install-test-env.sh <python> <dspy>` builds `.venv` from one group's
   locked tree, as each `sdk-test` leg in `ci-sdk.yml` does. From the repo root,
   run `just sdk-test-env 3.13 3.3.0`, then, from `python-sdk/`,
-  `.venv/bin/python -m pytest tests/ -k "not e2e"`. `uv sync --extra dev` in
+  `.venv/bin/python -m pytest tests/ -k "not e2e"`. The root recipe
+  `SDK_TEST_PYTHON_VERSION=3.13 SDK_TEST_DSPY_VERSION=3.4.0 just sdk-test-linux`
+  runs the same locked environment in Linux. `SDK_TEST_LINUX_IMAGE` selects a
+  pinned CI builder when reproducing a job. The helper copies the worker pins
+  and truncation vectors and mounts Git metadata read-only for revision tests.
+  The revision tests require Git, which the CI builder provides.
+  `uv sync --extra dev` in
   `python-sdk/` returns to the default group.
 - `--latest` resolves every package fresh, as a user's install today would.
   With the DSPy version `newest` it pins no DSPy either. The daily

{cmpnd-0.83.0 → cmpnd-0.85.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.83.0
+Version: 0.85.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>
@@ -685,7 +685,7 @@ cmpnd.configure(
     flush_interval_seconds=5.0,            # optional: seconds between flushes
     capture_inputs=True,                   # optional: record span inputs
     capture_outputs=True,                  # optional: record span outputs
-    default_tags={"env": "prod"},          # optional: tags on every trace
+    default_tags={"env": "prod"},          # optional: tags on every trace; a run's own tags override them
 )
 ```
 

{cmpnd-0.83.0 → cmpnd-0.85.0}/README.md

@@ -634,7 +634,7 @@ cmpnd.configure(
     flush_interval_seconds=5.0,            # optional: seconds between flushes
     capture_inputs=True,                   # optional: record span inputs
     capture_outputs=True,                  # optional: record span outputs
-    default_tags={"env": "prod"},          # optional: tags on every trace
+    default_tags={"env": "prod"},          # optional: tags on every trace; a run's own tags override them
 )
 ```
 

{cmpnd-0.83.0 → cmpnd-0.85.0}/cmpnd/callback.py

@@ -538,6 +538,7 @@ class _CallbackBase:
         stream_trace_starts: bool | None = None,
         own_config: configuration.Config | None = None,
         optimization_phase: str | None = None,
+        producer_context: dict[str, Any] | None = None,
     ) -> None:
         # A client passes its own config here; the auto_instrument callback leaves
         # it None and reads the process-global config live, so a reconfigure()
@@ -547,6 +548,24 @@ class _CallbackBase:
         # later cmpnd.configure(). That fixedness is what keeps a client
         # orthogonal to the global config.
         self._own_config = own_config
+        producer_context = producer_context or {}
+        self._producer_references = tuple(
+            (name, producer_context[name])
+            for name in (
+                "program_id",
+                "deployment_id",
+                "deployment_run_id",
+                "optimization_run_id",
+                "eval_run_id",
+                "compiled_from_run_id",
+            )
+            if producer_context.get(name) is not None
+        )
+        self._producer_tags = tuple((producer_context.get("tags") or {}).items())
+        self._producer_metadata = tuple((producer_context.get("metadata") or {}).items())
+        self._producer_projects = (
+            tuple(producer_context["project_tags"]) if "project_tags" in producer_context else None
+        )
         # The optimization phase this callback traces for a run it does not own: an
         # executor that scores a hosted rollout with the author's metric ("metric") or runs
         # the author's GEPA proposer ("reflection"). Such a process knows the program the
@@ -621,7 +640,7 @@ class _CallbackBase:
 
         # Active optimization run ID - stored on instance for same thread-safety reason.
         # Prefixed text id (`op_…`), minted via cmpnd.identity.
-        self._active_optimization_run_id: str | None = None
+        self._active_optimization_run_id: str | None = dict(self._producer_references).get("optimization_run_id")
 
         # Token usage from LM calls without a trace context (e.g., GEPA reflection calls)
         # Accumulated during optimization and included in the finalization payload
@@ -668,18 +687,20 @@ class _CallbackBase:
         # repl_history (see _AdapterMixin._thin_rlm_adapter_inputs).
         self._rlm_turn_adapter_spans: set[UUID] = set()
 
-        # Parent span -> the last adapter ``format`` span under it and its full
-        # rendered messages, for the LM call that follows to reference. See
-        # _AdapterMixin._remember_rendered_messages and _LMMixin.on_lm_start.
-        self._rendered_messages: dict[UUID, tuple[models.SpanBuilder, Any]] = {}
+        # Parent span -> the last adapter ``format`` span under it and the full
+        # value of each prompt key it stored whole, for the LM calls that follow
+        # to reference. See _AdapterMixin._remember_rendered_prompt and
+        # _LMMixin._reference_rendered_prompt.
+        self._rendered_prompts: dict[UUID, tuple[models.SpanBuilder, dict[str, Any]]] = {}
 
         # Open module span -> id() of its module instance, so an adapter span can
         # name the predictor it renders for. And (trace, predictor) -> the last
-        # rendering of each message index that serve can rebuild in full, as
-        # (the format span storing it, its full text). Dropped when the trace
-        # ends. See _AdapterMixin._extend_previous_rendering.
+        # rendering of each prompt text that serve can rebuild in full, by its
+        # path in the format span's outputs, as (the format span storing it, its
+        # full text). Dropped when the trace ends. See
+        # _AdapterMixin._extend_previous_rendering.
         self._module_instance_by_span: dict[UUID, int] = {}
-        self._last_rendering: dict[tuple[str, int], list[tuple[UUID, str] | None]] = {}
+        self._last_rendering: dict[tuple[str, int], dict[tuple[str | int, ...], tuple[UUID, str]]] = {}
 
         # Ensure exporter is running
         self._ensure_exporter()
@@ -722,19 +743,18 @@ class _CallbackBase:
         return configuration._current_program_id()
 
     def _stamp(self, builder: Any) -> Any:
-        """Stamp this callback's project tags, and on a trace its program, onto a
-        builder it just created. A span's program is its trace's, so a span carries
-        no program of its own.
+        """Stamp this callback's trace context before any spans begin.
 
         A trace from a call that declares a program name carries the name and no id,
         and the exporter resolves the name. The declared name wins over a program id the
         client's config read from ``CMPND_PROGRAM_ID``, and the callback warns once that it did.
         A trace that gets neither gets a generated name in `_create_trace`.
         """
-        builder.project_tags = self._resolve_project_tags()
         if isinstance(builder, models.TraceBuilder):
-            program_id = self._resolve_program_id()
-            name = _declared_program_name()
+            builder.project_tags = list(self._resolve_project_tags() or ())
+            producer_program_id = dict(self._producer_references).get("program_id")
+            program_id = producer_program_id or self._resolve_program_id()
+            name = None if producer_program_id else _declared_program_name()
             if name is not None:
                 if program_id is not None and not self._warned_name_over_id:
                     self._warned_name_over_id = True
@@ -765,6 +785,18 @@ class _CallbackBase:
             return _exporter_pool.ensure_exporter_started(self._own_config)
         return exporter.get_exporter()
 
+    def _apply_producer_context(self, trace: models.TraceBuilder) -> None:
+        for name, value in self._producer_references:
+            setattr(trace, name, value)
+        if dict(self._producer_references).get("program_id") is not None:
+            trace.declared_name = trace.generated_name = None
+        if self._producer_projects is not None:
+            trace.project_tags = list(self._producer_projects)
+        # A run's tags and metadata are more specific than the process defaults
+        # already on the trace, so they override them.
+        trace.tags.update(self._producer_tags)
+        trace.metadata.update(self._producer_metadata)
+
     def _ensure_exporter(self) -> Any:
         """Start this callback's exporter if it is not already running."""
         if self._own_config is not None:
@@ -780,6 +812,60 @@ class _CallbackBase:
         span makes ``to_api_dict`` bound the whole body by the same limits rather
         than by the 64 KiB default.
         """
+        if context.get_current_trace() is None:
+            config = self._own_config or configuration.get_config()
+            kwargs.setdefault(
+                "project_tags",
+                list(
+                    self._producer_projects
+                    if self._producer_projects is not None
+                    else self._resolve_project_tags() or ()
+                ),
+            )
+            # Most specific wins: process defaults, then the run's tags, then the span's own.
+            kwargs["tags"] = {
+                **(config.default_tags if config else {}),
+                **dict(self._producer_tags),
+                **kwargs.get("tags", {}),
+            }
+            for key, value in self._producer_references:
+                kwargs.setdefault(key, value)
+            run_id = self._active_optimization_run_id or context.get_current_optimization_run_id()
+            kwargs.setdefault("optimization_run_id", run_id)
+            kwargs.setdefault("eval_run_id", self._active_eval_run.eval_run_id if self._active_eval_run else None)
+            program_id = (
+                kwargs.get("program_id") or self._resolve_program_id() or context.optimization_program_id(run_id)
+            )
+            declared = None if kwargs.get("program_id") else _declared_program_name()
+            if declared is not None:
+                program_id = None
+            kwargs.setdefault("program_id", program_id)
+            from cmpnd_ingest.program_names import ProgramName
+            from cmpnd_ingest.span_context import ExportContext, SpanContext
+
+            kwargs.setdefault(
+                "export_context",
+                ExportContext(
+                    ProgramName(declared) if declared else None,
+                    program_id,
+                    declared is None or program_id is not None,
+                ),
+            )
+            phase = self._optimization_phase or (
+                ("metric" if self._active_eval_run else "reflection") if run_id else None
+            )
+            if phase is not None:
+                kwargs["tags"]["optimization_phase"] = phase
+            kwargs.setdefault(
+                "span_context",
+                SpanContext(
+                    project_tags=tuple(kwargs["project_tags"]),
+                    tags=tuple(kwargs["tags"].items()),
+                    program_id=program_id,
+                    optimization_run_id=kwargs["optimization_run_id"],
+                    eval_run_id=kwargs["eval_run_id"],
+                ),
+            )
         return context.create_child_span(
             name,
             span_type,
@@ -974,7 +1060,7 @@ class _ModuleMixin(_CallbackBase):
 
         # An adapter rendering this module's prompt is only ever referenced by an
         # LM call under this module, which has ended with it.
-        self._rendered_messages.pop(span.span_id, None)
+        self._rendered_prompts.pop(span.span_id, None)
         self._module_instance_by_span.pop(span.span_id, None)
 
         # RLM repl_history: append trajectory data from PREDICT children
@@ -1129,9 +1215,9 @@ class _ModuleMixin(_CallbackBase):
 
     def _forget_trace_references(self, trace_id: UUID) -> None:
         """Drop the per-trace state reference encoding keeps, once the trace ends."""
-        for parent, (fmt_span, _) in list(self._rendered_messages.items()):
+        for parent, (fmt_span, _) in list(self._rendered_prompts.items()):
             if fmt_span.trace_id == trace_id:
-                self._rendered_messages.pop(parent, None)
+                self._rendered_prompts.pop(parent, None)
         for key in [k for k in self._last_rendering if k[0] == str(trace_id)]:
             self._last_rendering.pop(key, None)
 
@@ -1220,7 +1306,7 @@ class _ModuleMixin(_CallbackBase):
 
     def _create_trace(self, instance: Any, inputs: dict[str, Any]) -> models.TraceBuilder:
         """Create a new trace for a root module call."""
-        config = configuration.get_config()
+        config = self._own_config or configuration.get_config()
 
         trace = models.TraceBuilder(
             trace_id=uuid4(),
@@ -1364,16 +1450,16 @@ class _ModuleMixin(_CallbackBase):
         preview = helpers.create_preview(helpers.clean_inputs(inputs, dspy, self._max_input_field_size))
         trace.request_preview = preview
 
-        # Apply default tags
+        # Process default tags first, then the run's own labels over them.
         if config and config.default_tags:
             trace.tags.update(config.default_tags)
+        self._apply_producer_context(trace)
         # A trace opened while this callback traces a phase, or while a local run
         # calls its metric, is the metric's or the proposer's, never a rollout, even
         # when its module is the program's own class.
         phase = self._optimization_phase or context.get_current_optimization_phase()
         if phase is not None:
             trace.tags["optimization_phase"] = phase
-
         return trace
 
     def _extract_usage_from_prediction(self, span: models.SpanBuilder, outputs: Any, dspy: Any) -> None:
@@ -1456,39 +1542,53 @@ class _LMMixin(_CallbackBase):
 
         # Capture prompt/messages if enabled. A credential passed to the call itself, as in
         # `lm(prompt, api_key=...)`, is stripped first: every member of the org reads a span.
+        # The rendered prompt becomes a reference before truncation, so the rest of the
+        # inputs keep the whole budget.
         if self._capture_prompts:
-            cleaned_inputs = helpers.clean_inputs(helpers.without_credentials(inputs), dspy, self._max_input_field_size)
-            self._reference_rendered_messages(parent_span, inputs, cleaned_inputs)
-            span.set_inputs(cleaned_inputs)
+            referenced = self._reference_rendered_prompt(parent_span, helpers.without_credentials(inputs))
+            span.set_inputs(helpers.clean_inputs(referenced, dspy, self._max_input_field_size))
 
         self._call_id_to_span[call_id] = span
         # Store LM instance reference to access history for token usage
         self._call_id_to_instance[call_id] = instance
         context.push_span(span)
 
-    def _reference_rendered_messages(
-        self, parent_span: models.SpanBuilder | None, inputs: dict[str, Any], cleaned: dict[str, Any]
-    ) -> None:
-        """Store the LM's messages as a reference to the adapter output they came from.
+    def _reference_rendered_prompt(
+        self, parent_span: models.SpanBuilder | None, inputs: dict[str, Any]
+    ) -> dict[str, Any]:
+        """``inputs`` with the rendered prompt as references to the adapter output it came from.
 
         The adapter's ``format`` span ended just before this call started, under
-        the same parent, and its ``outputs.result`` holds the rendered messages.
-        When the LM received exactly those, compared on the full values before any
-        truncation, ``messages`` becomes a ``_same_as`` reference to them; serve
-        resolves it on read. Anything else — messages the adapter changed after
-        rendering, or an LM call no adapter rendered for, such as an RLM
-        ``llm_query`` — keeps a full copy, so a mismatch costs bytes, never
-        correctness.
+        the same parent, and stored the rendered prompt (``references.prompt_keys``).
+        In the list shape, ``messages`` equal to the stored ``result`` becomes a
+        ``_same_as`` reference to it. In the typed shape, each of ``prompt.system``
+        and ``prompt.messages`` equal to the stored key becomes a reference to that
+        key, and the rest of the request stays inline. Values are compared in full,
+        before any truncation, and serve resolves the references on read.
+        Anything else, such as messages the adapter changed after rendering or an
+        LM call no adapter rendered for, like an RLM ``llm_query``, keeps a full
+        copy, so a mismatch costs bytes, never correctness. Each LM call the
+        adapter makes from one rendering gets the references.
         """
-        if parent_span is None or "messages" not in cleaned:
-            return
-        remembered = self._rendered_messages.pop(parent_span.span_id, None)
+        remembered = self._rendered_prompts.get(parent_span.span_id) if parent_span is not None else None
         if remembered is None:
-            return
+            return inputs
         fmt_span, rendered = remembered
-        if models._safe_serialize(inputs.get("messages")) != rendered:
-            return
-        cleaned["messages"] = references.same_as(str(fmt_span.span_id), "outputs", ["result"])
+        fmt_id = str(fmt_span.span_id)
+        if "result" in rendered:
+            if "messages" in inputs and models._safe_serialize(inputs["messages"]) == rendered["result"]:
+                return {**inputs, "messages": references.same_as(fmt_id, "outputs", ["result"])}
+            return inputs
+        if inputs.get("prompt") is None:
+            return inputs
+        prompt = models._safe_serialize(inputs["prompt"])
+        if not isinstance(prompt, dict):
+            return inputs
+        referenced = dict(prompt)
+        for key in references.TYPED_PROMPT_KEYS:
+            if key in rendered and key in prompt and prompt[key] == rendered[key]:
+                referenced[key] = references.same_as(fmt_id, "outputs", [key])
+        return inputs if referenced == prompt else {**inputs, "prompt": referenced}
 
     def on_lm_end(
         self,
@@ -1631,7 +1731,8 @@ class _LMMixin(_CallbackBase):
         # would double-count them in the optimization total.
         current_trace = context.get_current_trace()
         if current_trace is None and (
-            self._active_optimization_run_id is not None or self._optimization_phase is not None
+            (span.span_context is not None and span.span_context.optimization_run_id is not None)
+            or self._optimization_phase is not None
         ):
             self._emit_optimization_lm_trace(span)
             return  # handled as a standalone GEPA-process trace
@@ -1678,11 +1779,12 @@ class _LMMixin(_CallbackBase):
         instead, and may have no run id: it traces the metric or the proposer of a
         run whose id the ingest key the trace is pushed with decides.
         """
-        run_id = self._active_optimization_run_id
+        assert span.span_context is not None
+        run_id = span.span_context.optimization_run_id
         if not run_id and self._optimization_phase is None:
             return
 
-        phase = self._optimization_phase or ("metric" if self._active_eval_run is not None else "reflection")
+        phase = dict(span.span_context.tags).get("optimization_phase", "reflection")
         span.attributes["gepa.phase"] = phase
         span.attributes["optimization.role"] = _OPTIMIZATION_PHASE_ROLES[phase]
 
@@ -1692,11 +1794,14 @@ class _LMMixin(_CallbackBase):
             end_time=span.end_time,
             module_class="GEPA",
         )
-        self._stamp(trace)
-        # The call has no root module to name a program after, so a trace that declares
-        # neither an id nor a name takes the program the run optimizes.
-        if trace.program_id is None and trace.declared_name is None:
-            trace.program_id = context.optimization_program_id(run_id)
+        trace.program_id = span.span_context.program_id
+        trace.deployment_id = span.span_context.deployment_id
+        trace.deployment_run_id = span.span_context.deployment_run_id
+        trace.compiled_from_run_id = span.span_context.compiled_from_run_id
+        trace.project_tags = list(span.span_context.project_tags)
+        trace.tags = dict(span.span_context.tags)
+        trace.metadata = dict(self._producer_metadata)
+        trace._export_context = span.export_context
         # A metric-phase call can start while DSPy's Evaluate span is still on the
         # context stack, so on_lm_start stamped this span with a parent_span_id for
         # a span that isn't in this standalone one-span trace. This span IS the
@@ -1707,8 +1812,7 @@ class _LMMixin(_CallbackBase):
         trace.signature_name = span.model_name or phase
         trace.status = span.status
         trace.optimization_run_id = run_id
-        if self._active_eval_run is not None:
-            trace.eval_run_id = self._active_eval_run.eval_run_id
+        trace.eval_run_id = span.span_context.eval_run_id
         trace.tags["optimization_phase"] = phase
 
         # Single-span trace: roll the span's usage up onto the trace so the
@@ -1874,12 +1978,16 @@ class _AdapterMixin(_CallbackBase):
             if self._capture_outputs and outputs:
                 rendered = models._safe_serialize(outputs)
                 if span.span_type == models.SpanType.ADAPTER_FORMAT:
-                    # Encode against the previous rendering first, then truncate:
-                    # only a suffix that alone overflows the budget is cut.
-                    encoded = self._extend_previous_rendering(span, rendered)
-                    span.set_outputs(helpers.truncate_outputs(encoded, self._max_output_field_size))
-                    self._record_rendering(span, rendered)
-                    self._remember_rendered_messages(span, rendered)
+                    # The outputs as stored: a typed Prompt as its own dict, a list
+                    # of messages under "result". Encode against the previous
+                    # rendering first, then truncate: only a suffix that alone
+                    # overflows the budget is cut.
+                    body = rendered if isinstance(rendered, dict) else {"result": rendered}
+                    encoded = self._extend_previous_rendering(span, body)
+                    stored = encoded if isinstance(rendered, dict) else encoded["result"]
+                    span.set_outputs(helpers.truncate_outputs(stored, self._max_output_field_size))
+                    self._record_rendering(span, body)
+                    self._remember_rendered_prompt(span, body)
                 else:
                     span.set_outputs(helpers.truncate_outputs(rendered, self._max_output_field_size))
 
@@ -1904,78 +2012,81 @@ class _AdapterMixin(_CallbackBase):
         predictor = self._module_instance_by_span.get(span.parent_span_id)
         return None if predictor is None else (str(span.trace_id), predictor)
 
-    def _extend_previous_rendering(self, span: models.SpanBuilder, rendered: Any) -> Any:
-        """``rendered`` with each message that extends the predictor's last one encoded.
+    def _extend_previous_rendering(self, span: models.SpanBuilder, body: dict[str, Any]) -> dict[str, Any]:
+        """``body`` with each prompt text that extends the predictor's last one encoded.
 
         A predictor called once per turn — an RLM's action step, a ReAct step —
-        renders the previous turn's prompt plus what the turn added. For each
-        message whose content begins with the same-index message of the last
-        rendering this predictor stored in this trace, the content becomes an
-        ``_extends`` envelope over that stored message. Matching compares the full
-        rendered text and needs no knowledge of the module. The base may itself be
-        an extension, and serve resolves the chain.
+        renders the previous turn's prompt plus what the turn added. For each text
+        of the prompt (``references.prompt_text_leaves``) that begins with the text
+        at the same path in the last rendering this predictor stored in this trace,
+        the text becomes an ``_extends`` envelope over that stored text. In the
+        typed shape this covers the system prompt, which is the same on every turn,
+        as well as each message's text parts. Matching compares the full rendered
+        text and needs no knowledge of the module. The base may itself be an
+        extension, and serve resolves the chain.
         """
         key = self._rendering_key(span)
         previous = self._last_rendering.get(key) if key else None
-        if not previous or not isinstance(rendered, list):
-            return rendered
-        encoded = list(rendered)
-        for i, message in enumerate(rendered):
-            base = previous[i] if i < len(previous) else None
-            content = message.get("content") if isinstance(message, dict) else None
-            if base is None or not isinstance(content, str):
+        if not previous:
+            return body
+        encoded = body
+        for path, text in references.prompt_text_leaves(body):
+            base = previous.get(path)
+            if base is None:
                 continue
-            base_span_id, base_content = base
-            env = references.extends(
-                base_content, content, references.ref(str(base_span_id), "outputs", ["result", i, "content"])
-            )
+            base_span_id, base_text = base
+            env = references.extends(base_text, text, references.ref(str(base_span_id), "outputs", list(path)))
             if env is not None:
-                encoded[i] = {**message, "content": env}
+                encoded = references.with_value_at(encoded, path, env)
         return encoded
 
-    def _record_rendering(self, span: models.SpanBuilder, rendered: Any) -> None:
+    def _record_rendering(self, span: models.SpanBuilder, body: dict[str, Any]) -> None:
         """Keep this rendering as the base for the predictor's next one.
 
-        A message becomes the next base only where its stored form resolves to the
+        A text becomes the next base only where its stored form resolves to the
         full text: a whole string, or an extension whose suffix survived
-        truncation. Where it was cut, the previous base stays, so the next turn
-        extends a message serve can still rebuild.
+        truncation. Where it was cut, the previous base at that path stays, so the
+        next turn extends a text serve can still rebuild.
         """
         key = self._rendering_key(span)
-        stored = span.outputs.get("result") if isinstance(span.outputs, dict) else None
-        if key is None or not isinstance(rendered, list):
+        if key is None or not references.prompt_keys(body):
             return
-        previous = self._last_rendering.get(key) or []
-        current: list[tuple[UUID, str] | None] = []
-        for i, message in enumerate(rendered):
-            content = message.get("content") if isinstance(message, dict) else None
-            kept = stored[i] if isinstance(stored, list) and len(stored) == len(rendered) else None
-            kept_content = kept.get("content") if isinstance(kept, dict) else None
-            resolvable = kept_content == content or (
-                isinstance(kept_content, dict)
-                and set(kept_content) == {"_extends", "_prefix_chars", "_suffix"}
-                and isinstance(kept_content["_suffix"], str)
+        previous = self._last_rendering.get(key) or {}
+        current: dict[tuple[str | int, ...], tuple[UUID, str]] = {}
+        for path, text in references.prompt_text_leaves(body):
+            kept = references.value_at(span.outputs, path)
+            resolvable = kept == text or (
+                isinstance(kept, dict)
+                and set(kept) == {"_extends", "_prefix_chars", "_suffix"}
+                and isinstance(kept["_suffix"], str)
             )
-            if isinstance(content, str) and resolvable:
-                current.append((span.span_id, content))
-            else:
-                current.append(previous[i] if i < len(previous) else None)
+            if resolvable:
+                current[path] = (span.span_id, text)
+            elif path in previous:
+                current[path] = previous[path]
         self._last_rendering[key] = current
 
-    def _remember_rendered_messages(self, span: models.SpanBuilder, rendered: Any) -> None:
-        """Keep a ``format`` span's full rendered messages for the LM call that follows.
+    def _remember_rendered_prompt(self, span: models.SpanBuilder, body: dict[str, Any]) -> None:
+        """Keep a ``format`` span's full rendered prompt for the LM calls that follow.
 
-        The adapter hands exactly these messages to the LM, which starts after
-        this span ended, as its sibling under the same parent. ``on_lm_start``
-        compares its messages with them and writes a reference when they are
-        equal. Kept only when the stored output still holds the list at
-        ``outputs.result``: a list truncated whole into an envelope cannot be
-        walked into, and the LM span then keeps its own copy.
+        The adapter hands exactly this prompt to the LM, which starts after this
+        span ended, as its sibling under the same parent.
+        ``_reference_rendered_prompt`` compares the LM's prompt with it and writes
+        references where they are equal. A prompt key is kept only when its stored
+        value resolves in full: a list truncated into an envelope cannot be walked
+        into, and the LM span then keeps its own copy of that key.
         """
-        stored = span.outputs.get("result") if isinstance(span.outputs, dict) else None
-        if span.parent_span_id is None or not isinstance(rendered, list) or not isinstance(stored, list):
+        if span.parent_span_id is None:
             return
-        self._rendered_messages[span.parent_span_id] = (span, rendered)
+        kept = {}
+        for key in references.prompt_keys(body):
+            stored = references.value_at(span.outputs, (key,))
+            if stored is not None and references.resolves_in_full(stored):
+                kept[key] = body[key]
+        if kept:
+            self._rendered_prompts[span.parent_span_id] = (span, kept)
+        else:
+            self._rendered_prompts.pop(span.parent_span_id, None)
 
 
 class _ToolMixin(_CallbackBase):
@@ -2169,6 +2280,11 @@ class _InterpreterMixin(_CallbackBase):
             "parent_span": context.get_current_span(),
             "start_time": datetime.now(timezone.utc),
         }
+        trace = context.get_current_trace()
+        parent = frame["parent_span"]
+        frame["trace_id"] = trace.trace_id if trace else parent.trace_id
+        frame["span_context"] = trace.span_context() if trace else parent.span_context
+        frame["export_context"] = trace.export_context if trace else parent.export_context
         self._interpreter_tool_frames[call_id] = frame
         # Publish this frame as the one a nested on_tool_start marks, in this
         # context only. The token restores the prior frame (nested tool calls) on
@@ -2209,13 +2325,15 @@ class _InterpreterMixin(_CallbackBase):
         parent = frame["parent_span"]
         span = models.SpanBuilder(
             span_id=uuid4(),
-            trace_id=parent.trace_id if parent else None,
+            trace_id=frame["trace_id"],
             name=f"Tool.{frame['tool_name']}",
             span_type=models.SpanType.TOOL,
             parent_span_id=parent.span_id if parent else None,
             start_time=frame["start_time"],
             max_input_size=self._max_input_field_size,
             max_output_size=self._max_output_field_size,
+            span_context=frame["span_context"],
+            export_context=frame["export_context"],
         )
         span.attributes["tool.name"] = str(frame["tool_name"])
         span.attributes["tool.synthesized"] = "true"

{cmpnd-0.83.0 → cmpnd-0.85.0}/cmpnd/configuration.py

@@ -257,11 +257,11 @@ def require_config() -> Config:
 def _current_project_tags() -> list[str] | None:  # pyright: ignore[reportUnusedFunction]  # used cross-module as a dataclass default_factory
     """Read the currently-configured project tags, or None if unconfigured.
 
-    Called at payload serialization time so that a configure(project_tags=...)
-    call after a TraceBuilder is constructed still gets the fresh value.
+    Builders copy these values when execution begins, so later configuration
+    changes affect only future traces and spans.
     """
     cfg = get_config()
-    return cfg.project_tags if cfg else None
+    return list(cfg.project_tags) if cfg and cfg.project_tags is not None else None
 
 
 def _current_program_id() -> str | None:  # pyright: ignore[reportUnusedFunction]  # used cross-module as a dataclass default_factory