refactor(chat): drop "Latest" sentinel; show concrete artifact versions

The "Latest" label in the attach-artifact dialog implied live-sync
semantics that don't match reality — when the agent processes the
message, the selected version is snapshot into its namespace and
frozen. Replace it with the actual resolved-latest version number
so the snapshot is visible up front.

Backend:
- The bulk artifacts endpoint now returns the resolved-latest
  `version` per record. Free to compute: load_artifact_content_or_metadata
  already calls list_versions internally to resolve "latest"; we just
  stop discarding the result.

Frontend:
- AttachArtifactDialog's per-row picker drops the "Latest" sentinel.
  Default value = the artifact's backend-reported version. The full
  version list still lazy-loads on first open; until then the picker
  shows just the latest as its only option.
- The emitted URI always carries `?version=N` (concrete, never
  implicit). The agent translator's "latest"-fallback path remains
  for legacy URIs but is no longer exercised by the dialog.

Tests + the Storybook play test updated to match the new contract.

Author: amir-ghasemi

client/webui/frontend/src/lib/api/artifacts/hooks.ts

@@ -20,6 +20,7 @@ function transformArtifacts(artifacts: BulkArtifactsResponse["artifacts"]): Arti
         mime_type: artifact.mimeType ?? "application/octet-stream",
         last_modified: artifact.lastModified ?? new Date().toISOString(),
         uri: artifact.uri ?? "",
+        version: artifact.version ?? undefined,
         sessionId: artifact.sessionId,
         sessionName: artifact.sessionName,
         projectId: artifact.projectId ?? undefined,

client/webui/frontend/src/lib/api/artifacts/types.ts

@@ -10,6 +10,8 @@ export interface BulkArtifactsResponse {
         mimeType: string | null;
         lastModified: string | null;
         uri: string | null;
+        /** Resolved-latest version reported by the backend at list time. */
+        version: number | null;
         sessionId: string;
         sessionName: string | null;
         projectId: string | null;

client/webui/frontend/src/lib/components/chat/file/AttachArtifactDialog.tsx

@@ -10,30 +10,37 @@ import { formatBytes } from "@/lib/utils/format";
 import { getFileTypeColor } from "./FileIcon";
 import { getExtensionLabel } from "./attachmentUtils";
 
-const LATEST_VERSION_VALUE = "latest";
-
 /**
- * Inline per-row version picker. Lazy-loads versions on first open so a
- * dialog with 30+ artifacts doesn't fan out N list_versions calls upfront.
- * Mirrors the look of the side-panel `ArtifactDetails` selector.
+ * Inline per-row version picker. The default is the resolved-latest version
+ * provided by the bulk-list endpoint (a concrete number, not a "Latest"
+ * sentinel — that label would have falsely implied live-sync semantics; in
+ * practice the selected version is snapshot into the agent's namespace at
+ * attach time and frozen). The full version list is lazy-loaded on first
+ * open so a dialog with 30+ artifacts doesn't fan out N list_versions calls
+ * upfront. Mirrors the look of the side-panel `ArtifactDetails` selector.
  */
 const ArtifactVersionPicker: React.FC<{
     artifact: ArtifactWithSession;
-    value: string;
-    onValueChange: (value: string) => void;
+    value: number;
+    onValueChange: (value: number) => void;
 }> = ({ artifact, value, onValueChange }) => {
     const [hasOpened, setHasOpened] = useState(false);
-    const { data: versions, isLoading } = useArtifactVersions({
+    const { data: lazyVersions, isLoading } = useArtifactVersions({
         sessionId: artifact.sessionId,
         projectId: artifact.projectId,
         filename: artifact.filename,
         enabled: hasOpened,
     });
 
+    // Until the user opens the picker we only know the latest version (from
+    // the bulk-list response). Render that single option; the lazy fetch
+    // expands the list once they look.
+    const versions = lazyVersions ?? (typeof artifact.version === "number" ? [artifact.version] : []);
+
     return (
         <Select
-            value={value}
-            onValueChange={onValueChange}
+            value={value.toString()}
+            onValueChange={v => onValueChange(parseInt(v, 10))}
             onOpenChange={open => {
                 if (open) setHasOpened(true);
             }}
@@ -46,20 +53,19 @@ const ArtifactVersionPicker: React.FC<{
                     e.stopPropagation();
                 }}
             >
-                <SelectValue placeholder="Latest" />
+                <SelectValue />
             </SelectTrigger>
             <SelectContent
                 onClick={e => {
                     e.stopPropagation();
                 }}
             >
-                <SelectItem value={LATEST_VERSION_VALUE}>Latest</SelectItem>
                 {isLoading && (
                     <div className="flex items-center justify-center py-1">
                         <Spinner size="small" variant="muted" />
                     </div>
                 )}
-                {versions?.map(v => (
+                {versions.map(v => (
                     <SelectItem key={v} value={v.toString()}>
                         Version {v}
                     </SelectItem>
@@ -81,18 +87,16 @@ const resolveArtifactUri = (artifact: ArtifactWithSession): string | null => {
 };
 
 /**
- * Apply a per-row version override to a canonical artifact URI. "Latest" maps
- * to omitting `?version=` so the agent-side translator resolves the latest at
- * fetch time. A specific version is encoded as `?version=N`, replacing any
- * pre-existing query.
+ * Apply a concrete version to a canonical artifact URI as `?version=N`,
+ * replacing any pre-existing query. The version is always explicit (the
+ * dialog resolved "latest" to a concrete number when the row was rendered)
+ * so the snapshot semantics are visible end-to-end.
  */
-const applyVersionToUri = (uri: string, version: string): string => {
+const applyVersionToUri = (uri: string, version: number): string => {
     try {
         const url = new URL(uri);
         url.search = "";
-        if (version !== LATEST_VERSION_VALUE) {
-            url.searchParams.set("version", version);
-        }
+        url.searchParams.set("version", version.toString());
         return url.toString();
     } catch {
         return uri;
@@ -116,9 +120,10 @@ export const AttachArtifactDialog: React.FC<AttachArtifactDialogProps> = ({ isOp
     const { data: artifacts = [], isLoading, hasMore, loadMore, isLoadingMore } = useAllArtifacts(debouncedSearch || undefined);
 
     const [selectedKeys, setSelectedKeys] = useState<Set<string>>(new Set());
-    // Per-row version override; absent entry = "latest". Keyed the same way
-    // as `selectedKeys` so they can be looked up together when attaching.
-    const [versionByKey, setVersionByKey] = useState<Map<string, string>>(new Map());
+    // Per-row version override; absent entry = the artifact's own
+    // backend-resolved latest version. Keyed the same way as `selectedKeys` so
+    // they can be looked up together when attaching.
+    const [versionByKey, setVersionByKey] = useState<Map<string, number>>(new Map());
 
     // Reset state when dialog closes so it opens fresh next time.
     useEffect(() => {
@@ -169,10 +174,12 @@ export const AttachArtifactDialog: React.FC<AttachArtifactDialogProps> = ({ isOp
                 .filter(({ artifact }) => selectedKeys.has(keyFor(artifact)))
                 .map(({ artifact, resolvedUri }) => {
                     const baseUri = resolvedUri ?? artifact.uri;
-                    const versionChoice = versionByKey.get(keyFor(artifact)) ?? LATEST_VERSION_VALUE;
-                    // Encode the per-row version override on the URI so the
-                    // chat submit pipeline doesn't need to re-resolve it.
-                    const finalUri = baseUri ? applyVersionToUri(baseUri, versionChoice) : baseUri;
+                    // Use the per-row override if set, else the artifact's
+                    // backend-resolved latest version. Either way, the URI
+                    // always carries an explicit `?version=N` — no implicit
+                    // "latest" semantics survive into the submit pipeline.
+                    const versionChoice = versionByKey.get(keyFor(artifact)) ?? artifact.version;
+                    const finalUri = baseUri && typeof versionChoice === "number" ? applyVersionToUri(baseUri, versionChoice) : baseUri;
                     return { ...artifact, uri: finalUri };
                 }),
         [visibleArtifacts, selectedKeys, versionByKey]
@@ -243,17 +250,19 @@ export const AttachArtifactDialog: React.FC<AttachArtifactDialogProps> = ({ isOp
                                                     <div className="min-w-0 flex-1 truncate text-sm font-medium text-(--primary-text-wMain)" title={artifact.filename}>
                                                         {artifact.filename}
                                                     </div>
-                                                    <ArtifactVersionPicker
-                                                        artifact={artifact}
-                                                        value={versionByKey.get(k) ?? LATEST_VERSION_VALUE}
-                                                        onValueChange={v => {
-                                                            setVersionByKey(prev => {
-                                                                const next = new Map(prev);
-                                                                next.set(k, v);
-                                                                return next;
-                                                            });
-                                                        }}
-                                                    />
+                                                    {typeof artifact.version === "number" && (
+                                                        <ArtifactVersionPicker
+                                                            artifact={artifact}
+                                                            value={versionByKey.get(k) ?? artifact.version}
+                                                            onValueChange={v => {
+                                                                setVersionByKey(prev => {
+                                                                    const next = new Map(prev);
+                                                                    next.set(k, v);
+                                                                    return next;
+                                                                });
+                                                            }}
+                                                        />
+                                                    )}
                                                 </div>
                                                 <div className="flex items-center gap-2 text-xs text-(--secondary-text-wMain)">
                                                     <span className="truncate">{artifact.mime_type}</span>

client/webui/frontend/src/stories/chat/AttachArtifactDialog.stories.tsx

@@ -110,6 +110,10 @@ export const VersionPickerEncodesSelectedVersion: Story = {
                                 mimeType: "application/pdf",
                                 lastModified: "2026-01-01T00:00:00Z",
                                 uri: "artifact://my-app/user-1/sess-1/report.pdf",
+                                // Backend reports the resolved-latest version
+                                // so the picker can default to it without an
+                                // extra round-trip.
+                                version: 2,
                                 sessionId: "sess-1",
                                 sessionName: "Session One",
                                 projectId: null,
@@ -123,7 +127,7 @@ export const VersionPickerEncodesSelectedVersion: Story = {
                         nextPage: null,
                     });
                 }),
-                // The per-row picker lazy-fetches versions on first open.
+                // The per-row picker lazy-fetches the full version list on first open.
                 http.get("*/api/v1/artifacts/:sessionId/report.pdf/versions", () => {
                     return HttpResponse.json([0, 1, 2]);
                 }),

client/webui/frontend/src/stories/chat/AttachArtifactDialog.test.tsx

@@ -69,6 +69,7 @@ function toRawArtifact(a: ArtifactWithSession) {
         mimeType: a.mime_type,
         lastModified: a.last_modified,
         uri: a.uri,
+        version: a.version ?? null,
         sessionId: a.sessionId,
         sessionName: a.sessionName,
         projectId: a.projectId ?? null,
@@ -128,29 +129,29 @@ describe("AttachArtifactDialog", () => {
         expect(screen.getByText(/no artifacts available/i)).toBeInTheDocument();
     });
 
-    test("emits the canonical artifact:// URI without ?version when the user keeps the 'Latest' default", async () => {
-        // The /artifacts/all endpoint returns a canonical 4-segment URI
-        // without a `?version=N` query (the agent-side translator resolves
-        // "latest" at fetch time). The dialog forwards it untouched when the
-        // per-row version picker is left on its default.
+    test("encodes the backend-reported latest version on the emitted URI by default", async () => {
+        // The /artifacts/all endpoint returns the resolved-latest version
+        // alongside each record. The dialog uses that as the picker's
+        // default and bakes it into the URI as ?version=N — no implicit
+        // "latest" semantics survive into the submit pipeline.
         const canonical = "artifact://my-app/user-1/sess-legacy/legacy.txt";
         const onAttach = vi.fn();
-        renderDialog([makeArtifact({ filename: "legacy.txt", sessionId: "sess-legacy", uri: canonical })], { onAttach });
+        renderDialog([makeArtifact({ filename: "legacy.txt", sessionId: "sess-legacy", uri: canonical, version: 2 })], { onAttach });
 
         await userEvent.click(screen.getByText("legacy.txt"));
         await userEvent.click(screen.getByRole("button", { name: /attach 1/i }));
 
         expect(onAttach).toHaveBeenCalledTimes(1);
         const [emitted] = onAttach.mock.calls[0];
         expect(emitted).toHaveLength(1);
-        expect(emitted[0].uri).toBe(canonical);
+        expect(emitted[0].uri).toBe(`${canonical}?version=2`);
     });
 
     test("hides records that arrive without a canonical URI (treats them as unattachable)", () => {
         // Backend should always return `uri` on the bulk endpoint. If a record
         // arrives without one, the agent-side translator would reject any
         // fallback we synthesized — surface "unattachable" by hiding it.
-        renderDialog([makeArtifact({ filename: "broken.txt", sessionId: "sess-x", uri: "" })]);
+        renderDialog([makeArtifact({ filename: "broken.txt", sessionId: "sess-x", uri: "", version: 0 })]);
 
         expect(screen.queryByText("broken.txt")).not.toBeInTheDocument();
         expect(screen.getByText(/no artifacts available/i)).toBeInTheDocument();

src/solace_agent_mesh/agent/utils/artifact_helpers.py

@@ -1311,7 +1311,17 @@ async def _load_single_metadata(filename: str) -> Optional[ArtifactInfo]:
                     log_identifier_prefix=f"{log_prefix} [{filename}]",
                 )
 
-                info = _metadata_to_artifact_info(filename, data.get("metadata", {}))
+                # `version` is the metadata file's resolved-latest version,
+                # captured for free here (load_artifact_content_or_metadata
+                # already had to call list_versions to resolve "latest"). The
+                # WebUI's attach-artifact dialog uses this to pre-fill its
+                # version picker default with a concrete number rather than a
+                # "Latest" sentinel.
+                info = _metadata_to_artifact_info(
+                    filename,
+                    data.get("metadata", {}),
+                    version=data.get("version"),
+                )
                 # Populate the canonical 4-segment artifact:// URI so consumers
                 # (the chat-input attach dialog) can pass it to handleSubmit
                 # without falling back to a synthesized form the agent-side

src/solace_agent_mesh/gateway/http_sse/routers/artifacts.py

@@ -548,26 +548,31 @@ async def upload_artifact_with_session(
 
 class ArtifactWithContext(BaseModel):
     """Artifact info with session/project context for bulk listing."""
-    
+
     # Core artifact fields from ArtifactInfo
     filename: str
     size: int
     mime_type: Optional[str] = Field(None, alias="mimeType")
     last_modified: Optional[str] = Field(None, alias="lastModified")  # ISO date string
     uri: Optional[str] = None
-    
+    # Resolved-latest version captured during the metadata load (free —
+    # load_artifact_content_or_metadata had to call list_versions anyway).
+    # The WebUI uses this so the attach-artifact dialog can default its
+    # version picker to a concrete number instead of a "Latest" sentinel.
+    version: Optional[int] = None
+
     # Context fields
     session_id: str = Field(..., alias="sessionId")
     session_name: Optional[str] = Field(None, alias="sessionName")
     project_id: Optional[str] = Field(None, alias="projectId")
     project_name: Optional[str] = Field(None, alias="projectName")
-    
+
     # Source field for origin badges (upload, generated, project)
     source: Optional[str] = None
-    
+
     # Tags for categorization (e.g., ["__working"] to mark as internal)
     tags: Optional[list[str]] = None
-    
+
     model_config = {"populate_by_name": True}
 
 
@@ -835,6 +840,7 @@ async def _fetch_session_artifacts(
                         mime_type=artifact.mime_type,
                         last_modified=artifact.last_modified,
                         uri=artifact.uri,
+                        version=artifact.version,
                         session_id=session_id,
                         session_name=session_name,
                         project_id=project_id,