solana-agent 31.1.1__py3-none-any.whl → 31.1.3__py3-none-any.whl

solana_agent/services/query.py

@@ -80,7 +80,7 @@ class QueryService(QueryServiceInterface):
         router: Optional[RoutingServiceInterface] = None,
         output_model: Optional[Type[BaseModel]] = None,
         capture_schema: Optional[Dict[str, Any]] = None,
-        capture_name: Optional[str] = None,
+        capture_name: Optional[Dict[str, Any]] = None,
     ) -> AsyncGenerator[Union[str, bytes, BaseModel], None]:  # pragma: no cover
         """Process the user request and generate a response."""
         try:
@@ -200,7 +200,9 @@ class QueryService(QueryServiceInterface):
 
             # 7) Captured data context + incremental save using previous assistant message
             capture_context = ""
-            form_complete = False
+            # Two completion flags:
+            required_complete = False
+            form_complete = False  # required + optional
 
             # Helpers
             def _non_empty(v: Any) -> bool:
@@ -215,7 +217,6 @@ class QueryService(QueryServiceInterface):
 
             def _parse_numbers_list(s: str) -> List[str]:
                 nums = re.findall(r"\b(\d+)\b", s)
-                # dedupe keep order
                 seen, out = set(), []
                 for n in nums:
                     if n not in seen:
@@ -225,9 +226,7 @@ class QueryService(QueryServiceInterface):
 
             def _extract_numbered_options(text: str) -> Dict[str, str]:
                 """Parse previous assistant message for lines like:
-                '1) Foo', '2. Bar', '- 3) Baz', '* 4. Buzz'
-                Returns mapping '1' -> 'Foo', etc.
-                """
+                '1) Foo', '1. Foo', '- 1) Foo', '* 1. Foo' -> {'1': 'Foo'}"""
                 options: Dict[str, str] = {}
                 if not text:
                     return options
@@ -235,44 +234,109 @@ class QueryService(QueryServiceInterface):
                     line = raw.strip()
                     if not line:
                         continue
-                    # Common Markdown patterns: "1. Label", "1) Label", "- 1) Label", "* 1. Label"
                     m = re.match(r"^(?:[-*]\s*)?(\d+)[\.)]?\s+(.*)$", line)
                     if m:
-                        idx, label = m.group(1), m.group(2).strip()
-                        # Strip trailing markdown soft-break spaces
-                        label = label.rstrip()
-                        # Ignore labels that are too short or look like continuations
+                        idx, label = m.group(1), m.group(2).strip().rstrip()
                         if len(label) >= 1:
                             options[idx] = label
                 return options
 
-            def _detect_field_from_prev_question(
+            # LLM-backed field detection (gpt-4.1-mini) with graceful fallbacks
+            class _FieldDetect(BaseModel):
+                field: Optional[str] = None
+
+            async def _detect_field_from_prev_question(
                 prev_text: str, schema: Optional[Dict[str, Any]]
             ) -> Optional[str]:
                 if not prev_text or not isinstance(schema, dict):
                     return None
-                t = prev_text.lower()
-                # Heuristic synonyms for your onboarding schema
-                patterns = [
-                    ("ideas", ["which ideas attract you", "ideas"]),
-                    ("description", ["please describe yourself", "describe yourself"]),
-                    ("myself", ["tell us about yourself", "about yourself"]),
-                    ("questions", ["do you have any questions"]),
-                    ("rating", ["rating", "1 to 5", "how satisfied", "how happy"]),
-                    ("email", ["email"]),
-                    ("phone", ["phone"]),
-                    ("name", ["name"]),
-                    ("city", ["city"]),
-                    ("state", ["state"]),
-                ]
-                candidates = set((schema.get("properties") or {}).keys())
-                for field, keys in patterns:
-                    if field in candidates and any(key in t for key in keys):
-                        return field
-                # Fallback: property name appears directly
-                for field in candidates:
-                    if field in t:
-                        return field
+                props = list((schema.get("properties") or {}).keys())
+                if not props:
+                    return None
+
+                question = prev_text.strip()
+                instruction = (
+                    "You are a strict classifier. Given the assistant's last question and a list of "
+                    "permitted schema field keys, choose exactly one key that the question is asking the user to answer. "
+                    "If none apply, return null."
+                )
+                user_prompt = (
+                    f"Schema field keys (choose exactly one of these): {props}\n"
+                    f"Assistant question:\n{question}\n\n"
+                    'Return strictly JSON like: {"field": "<one_of_the_keys_or_null>"}'
+                )
+
+                # Try llm_provider.parse_structured_output with mini
+                try:
+                    if hasattr(
+                        self.agent_service.llm_provider, "parse_structured_output"
+                    ):
+                        try:
+                            result = await self.agent_service.llm_provider.parse_structured_output(
+                                prompt=user_prompt,
+                                system_prompt=instruction,
+                                model_class=_FieldDetect,
+                                model="gpt-4.1-nano",
+                            )
+                        except TypeError:
+                            # Provider may not accept 'model' kwarg
+                            result = await self.agent_service.llm_provider.parse_structured_output(
+                                prompt=user_prompt,
+                                system_prompt=instruction,
+                                model_class=_FieldDetect,
+                            )
+                        # Read result
+                        sel = None
+                        try:
+                            sel = getattr(result, "field", None)
+                        except Exception:
+                            sel = None
+                        if sel is None:
+                            try:
+                                d = result.model_dump()
+                                sel = d.get("field")
+                            except Exception:
+                                sel = None
+                        if sel in props:
+                            return sel
+                except Exception as e:
+                    logger.debug(
+                        f"LLM parse_structured_output field detection failed: {e}"
+                    )
+
+                # Fallback: use generate_response with output_model=_FieldDetect
+                try:
+                    async for r in self.agent_service.generate_response(
+                        agent_name=agent_name,
+                        user_id=user_id,
+                        query=user_text,
+                        images=images,
+                        memory_context="",
+                        output_format="text",
+                        prompt=f"{instruction}\n\n{user_prompt}",
+                        output_model=_FieldDetect,
+                    ):
+                        fd = r
+                        sel = None
+                        try:
+                            sel = fd.field  # type: ignore[attr-defined]
+                        except Exception:
+                            try:
+                                d = fd.model_dump()
+                                sel = d.get("field")
+                            except Exception:
+                                sel = None
+                        if sel in props:
+                            return sel
+                        break
+                except Exception as e:
+                    logger.debug(f"LLM generate_response field detection failed: {e}")
+
+                # Final heuristic fallback (keeps system working if LLM unavailable)
+                t = question.lower()
+                for key in props:
+                    if key in t:
+                        return key
                 return None
 
             # Resolve active capture from args or agent config
@@ -322,33 +386,43 @@ class QueryService(QueryServiceInterface):
                     required_fields = list(
                         (active_capture_schema or {}).get("required", []) or []
                     )
-                    # Prefer a field detected from prev assistant; else if exactly one required missing, use it
-                    target_field: Optional[str] = _detect_field_from_prev_question(
-                        prev_assistant, active_capture_schema
-                    )
+                    all_fields = list(props.keys())
+                    optional_fields = [
+                        f for f in all_fields if f not in set(required_fields)
+                    ]
+
                     active_data_existing = (
                         latest_by_name.get(active_capture_name, {}) or {}
                     ).get("data", {}) or {}
 
-                    def _missing_required() -> List[str]:
+                    def _missing(fields: List[str]) -> List[str]:
                         return [
                             f
-                            for f in required_fields
+                            for f in fields
                             if not _non_empty(active_data_existing.get(f))
                         ]
 
+                    missing_required = _missing(required_fields)
+                    missing_optional = _missing(optional_fields)
+
+                    target_field: Optional[
+                        str
+                    ] = await _detect_field_from_prev_question(
+                        prev_assistant, active_capture_schema
+                    )
                     if not target_field:
-                        missing = _missing_required()
-                        if len(missing) == 1:
-                            target_field = missing[0]
+                        # If exactly one required missing, target it; else if none required missing and exactly one optional missing, target it.
+                        if len(missing_required) == 1:
+                            target_field = missing_required[0]
+                        elif len(missing_required) == 0 and len(missing_optional) == 1:
+                            target_field = missing_optional[0]
 
-                    if target_field:
+                    if target_field and target_field in props:
                         f_schema = props.get(target_field, {}) or {}
                         f_type = f_schema.get("type")
                         number_to_label = _extract_numbered_options(prev_assistant)
 
                         if number_to_label:
-                            # Map any numbers in user's reply to their labels
                             nums = _parse_numbers_list(user_text)
                             labels = [
                                 number_to_label[n] for n in nums if n in number_to_label
@@ -359,7 +433,6 @@ class QueryService(QueryServiceInterface):
                                 else:
                                     incremental[target_field] = labels[0]
 
-                        # If we didn't map via options, fallback to type-based parse
                         if target_field not in incremental:
                             if f_type == "number":
                                 m = re.search(r"\b([0-9]+(?:\.[0-9]+)?)\b", user_text)
@@ -369,7 +442,6 @@ class QueryService(QueryServiceInterface):
                                     except Exception:
                                         pass
                             elif f_type == "array":
-                                # Accept CSV-style input as array of strings
                                 parts = [
                                     p.strip()
                                     for p in re.split(r"[,\n;]+", user_text)
@@ -377,11 +449,10 @@ class QueryService(QueryServiceInterface):
                                 ]
                                 if parts:
                                     incremental[target_field] = parts
-                            else:  # string/default
+                            else:
                                 if user_text.strip():
                                     incremental[target_field] = user_text.strip()
 
-                    # Filter out empty junk and save
                     if incremental:
                         cleaned = {
                             k: v for k, v in incremental.items() if _non_empty(v)
@@ -397,6 +468,7 @@ class QueryService(QueryServiceInterface):
                                 )
                             except Exception as se:
                                 logger.error(f"Error saving incremental capture: {se}")
+
             except Exception as e:
                 logger.debug(f"Incremental extraction skipped: {e}")
 
@@ -411,19 +483,33 @@ class QueryService(QueryServiceInterface):
 
             lines: List[str] = []
             if active_capture_name and isinstance(active_capture_schema, dict):
-                active_data = _get_active_data(active_capture_name)
+                props = (active_capture_schema or {}).get("properties", {})
                 required_fields = list(
                     (active_capture_schema or {}).get("required", []) or []
                 )
-                missing = [
-                    f for f in required_fields if not _non_empty(active_data.get(f))
+                all_fields = list(props.keys())
+                optional_fields = [
+                    f for f in all_fields if f not in set(required_fields)
                 ]
-                form_complete = len(missing) == 0 and len(required_fields) > 0
+
+                active_data = _get_active_data(active_capture_name)
+
+                def _missing_from(data: Dict[str, Any], fields: List[str]) -> List[str]:
+                    return [f for f in fields if not _non_empty(data.get(f))]
+
+                missing_required = _missing_from(active_data, required_fields)
+                missing_optional = _missing_from(active_data, optional_fields)
+
+                required_complete = (
+                    len(missing_required) == 0 and len(required_fields) > 0
+                )
+                form_complete = required_complete and len(missing_optional) == 0
 
                 lines.append(
                     "CAPTURED FORM STATE (Authoritative; do not re-ask filled values):"
                 )
                 lines.append(f"- form_name: {active_capture_name}")
+
                 if active_data:
                     pairs = [
                         f"{k}: {v}" for k, v in active_data.items() if _non_empty(v)
@@ -433,8 +519,12 @@ class QueryService(QueryServiceInterface):
                     )
                 else:
                     lines.append("- filled_fields: (none)")
+
+                lines.append(
+                    f"- missing_required_fields: {', '.join(missing_required) if missing_required else '(none)'}"
+                )
                 lines.append(
-                    f"- missing_required_fields: {', '.join(missing) if missing else '(none)'}"
+                    f"- missing_optional_fields: {', '.join(missing_optional) if missing_optional else '(none)'}"
                 )
                 lines.append("")
 
@@ -455,7 +545,7 @@ class QueryService(QueryServiceInterface):
             if lines:
                 capture_context = "\n".join(lines) + "\n\n"
 
-            # Merge contexts
+            # Merge contexts + flow rules
             combined_context = ""
             if capture_context:
                 combined_context += capture_context
@@ -470,9 +560,11 @@ class QueryService(QueryServiceInterface):
                     "- Prefer KB/tools for facts.\n"
                     "- History is for tone and continuity.\n\n"
                     "FORM FLOW RULES:\n"
-                    "- Ask exactly one missing required field per turn.\n"
+                    "- Ask exactly one field per turn.\n"
+                    "- If any required fields are missing, ask the next missing required field.\n"
+                    "- If all required fields are filled but optional fields are missing, ask the next missing optional field.\n"
                     "- Do NOT re-ask or verify values present in Captured User Data (auto-saved, authoritative).\n"
-                    "- If no required fields are missing, proceed without further capture questions.\n\n"
+                    "- Do NOT provide summaries until no required or optional fields are missing.\n\n"
                 )
 
             # 8) Generate response
@@ -510,7 +602,7 @@ class QueryService(QueryServiceInterface):
                     except Exception:
                         pass
 
-                # If form is complete, ask for structured output JSON
+                # Only run final structured output when no required or optional fields are missing
                 if capture_schema and capture_name and form_complete:
                     try:
                         DynamicModel = self._build_model_from_json_schema(

{solana_agent-31.1.1.dist-info → solana_agent-31.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 31.1.1
+Version: 31.1.3
 Summary: AI Agents for Solana
 License: MIT
 Keywords: solana,solana ai,solana agent,ai,ai agent,ai agents

{solana_agent-31.1.1.dist-info → solana_agent-31.1.3.dist-info}/RECORD

@@ -34,10 +34,10 @@ solana_agent/repositories/memory.py,sha256=F46vZ-Uhj7PX2uFGCRKYsZ8JLmKteMN1d30qG
 solana_agent/services/__init__.py,sha256=iko0c2MlF8b_SA_nuBGFllr2E3g_JowOrOzGcnU9tkA,162
 solana_agent/services/agent.py,sha256=dotuINMtW3TQDLq2eNM5r1cAUwhzxbHBotw8p5CLsYU,20983
 solana_agent/services/knowledge_base.py,sha256=ZvOPrSmcNDgUzz4bJIQ4LeRl9vMZiK9hOfs71IpB7Bk,32735
-solana_agent/services/query.py,sha256=FwqZMmuLUI7TmAkzv91D363PfnWajww35s8j5ubatY4,31544
+solana_agent/services/query.py,sha256=ekvuwkhLobg56sIKwHTR13GFL_TV7VkfafA0VmOxkMg,35608
 solana_agent/services/routing.py,sha256=hsHe8HSGO_xFc0A17WIOGTidLTfLSfApQw3l2HHqkLo,7614
-solana_agent-31.1.1.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
-solana_agent-31.1.1.dist-info/METADATA,sha256=Ke1JR65TFAZ3YAE4V_x-WbVXvMfkF-2aj_Hs2xlgcxQ,30013
-solana_agent-31.1.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-solana_agent-31.1.1.dist-info/entry_points.txt,sha256=-AuT_mfqk8dlZ0pHuAjx1ouAWpTRjpqvEUa6YV3lmc0,53
-solana_agent-31.1.1.dist-info/RECORD,,
+solana_agent-31.1.3.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
+solana_agent-31.1.3.dist-info/METADATA,sha256=q1PWQGGolVgn2xKH_NtbETngkTybMBS_bp1JQGEUxx4,30013
+solana_agent-31.1.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+solana_agent-31.1.3.dist-info/entry_points.txt,sha256=-AuT_mfqk8dlZ0pHuAjx1ouAWpTRjpqvEUa6YV3lmc0,53
+solana_agent-31.1.3.dist-info/RECORD,,