@tiens.nguyen/gonext-local-worker 1.0.192 → 1.0.194

package/gonext_agent_chat.py

@@ -3288,6 +3288,14 @@ def run_agent_chat(cfg):
             text = (_last_obs.get("text") or "").strip()
             if text:
                 _log(f"max-steps fallback (last tool obs) → {text[:80]}")
+                # Without this, `text` (a tool's RAW return value — e.g. a bare grep_repo
+                # dump of file:line hits) becomes the entire chat reply with zero framing,
+                # reading as a bizarre non-answer. A short honest note makes clear this is
+                # a partial result from an interrupted run, not the actual answer/edit.
+                text = (
+                    "I ran out of steps before finishing this. Here's the last thing I "
+                    "found — reply to have me continue from here:\n\n" + text
+                )
             else:
                 # No usable tool output (e.g. every step's code failed to parse).
                 # Don't dead-end on a canned apology — answer from the conversation.
@@ -3344,12 +3352,18 @@ def run_agent_chat(cfg):
                 path, cached = _rag_download(url, (dest_path or "").strip())
                 if cached:
                     _emit({"type": "step", "text": "Already downloaded — reusing cached file"})
-                    return (f"Already downloaded earlier — reusing {path} "
-                            f"({os.path.getsize(path)} bytes). Next: unzip_file(zip_path='{path}').")
+                    out = (f"Already downloaded earlier — reusing {path} "
+                           f"({os.path.getsize(path)} bytes). Next: unzip_file(zip_path='{path}').")
+                    _last_obs["text"] = out
+                    return out
                 _emit({"type": "step", "text": f"Downloading → {url[:80]}"})
-                return f"Downloaded to {path} ({os.path.getsize(path)} bytes). Next: unzip_file(zip_path='{path}') if it is a zip."
+                out = f"Downloaded to {path} ({os.path.getsize(path)} bytes). Next: unzip_file(zip_path='{path}') if it is a zip."
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: download failed: {type(e).__name__}: {e}"
+                msg = f"Error: download failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def unzip_file(zip_path: str, dest_dir: str = "") -> str:
@@ -3365,12 +3379,18 @@ def run_agent_chat(cfg):
                 more = f" …(+{len(names) - 15} more)" if len(names) > 15 else ""
                 if cached:
                     _emit({"type": "step", "text": "Already unzipped — reusing extracted files"})
-                    return (f"Already unzipped earlier — {len(names)} files at {d}. "
-                            f"Files: {preview}{more}. Use list_dir/read_text_file or rag_index on it.")
+                    out = (f"Already unzipped earlier — {len(names)} files at {d}. "
+                           f"Files: {preview}{more}. Use list_dir/read_text_file or rag_index on it.")
+                    _last_obs["text"] = out
+                    return out
                 _emit({"type": "step", "text": "Unzipping…"})
-                return f"Unzipped {len(names)} files to {d}. Files: {preview}{more}. Next: rag_index(path='{d}', source_url=<the original url>)."
+                out = f"Unzipped {len(names)} files to {d}. Files: {preview}{more}. Next: rag_index(path='{d}', source_url=<the original url>)."
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: unzip failed: {type(e).__name__}: {e}"
+                msg = f"Error: unzip failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def list_dir(path: str) -> str:
@@ -3383,7 +3403,9 @@ def run_agent_chat(cfg):
                 import os
                 root = _rag_read_allowed((path or ".").strip())
                 if os.path.isfile(root):
-                    return f"{root} is a file ({os.path.getsize(root)} bytes)."
+                    out = f"{root} is a file ({os.path.getsize(root)} bytes)."
+                    _last_obs["text"] = out
+                    return out
                 entries = []
                 for dirpath, dirnames, filenames in os.walk(root):
                     dirnames[:] = [d for d in dirnames if d not in _RAG_SKIP_DIRS]
@@ -3398,9 +3420,13 @@ def run_agent_chat(cfg):
                         break
                 entries.sort()
                 more = " …(truncated)" if len(entries) >= 300 else ""
-                return f"{len(entries)} files under {root}:\n" + "\n".join(entries) + more
+                out = f"{len(entries)} files under {root}:\n" + "\n".join(entries) + more
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: list_dir failed: {type(e).__name__}: {e}"
+                msg = f"Error: list_dir failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def read_text_file(path: str, max_chars: int = 20000) -> str:
@@ -3414,14 +3440,22 @@ def run_agent_chat(cfg):
                 import os
                 rp = _rag_read_allowed((path or "").strip())
                 if not os.path.isfile(rp):
-                    return f"Error: not a file: {path}"
+                    msg = f"Error: not a file: {path}"
+                    _last_obs["text"] = msg
+                    return msg
                 if os.path.getsize(rp) > 5 * 1024 * 1024:
-                    return "Error: file too large to read (> 5 MB)."
+                    msg = "Error: file too large to read (> 5 MB)."
+                    _last_obs["text"] = msg
+                    return msg
                 with open(rp, "r", encoding="utf-8", errors="replace") as fh:
                     data = fh.read(max(500, min(int(max_chars or 20000), 100000)))
-                return data or "(empty file)"
+                out = data or "(empty file)"
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: read_text_file failed: {type(e).__name__}: {e}"
+                msg = f"Error: read_text_file failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def rag_index(path: str, source_url: str) -> str:
@@ -3432,7 +3466,9 @@ def run_agent_chat(cfg):
                 source_url: the original URL the user gave — used as the knowledge-base key.
             """
             if not _RAG_AVAILABLE:
-                return "Error: RAG is not configured (enable it + add AWS credentials in Settings)."
+                msg = "Error: RAG is not configured (enable it + add AWS credentials in Settings)."
+                _last_obs["text"] = msg
+                return msg
             _emit({"type": "step", "text": f"RAG source → {source_url}"})
             _emit({"type": "step", "text": "Indexing files for RAG…"})
             try:
@@ -3448,7 +3484,9 @@ def run_agent_chat(cfg):
                     files += 1
                     records.extend(_rag_chunk_text(text, rel, ext))
                 if not records:
-                    return "No indexable text files found at that path."
+                    msg = "No indexable text files found at that path."
+                    _last_obs["text"] = msg
+                    return msg
                 for i in range(0, len(records), 64):
                     batch = records[i:i + 64]
                     vecs = _embed(rag_embed_base, rag_embed_model, [r["text"] for r in batch])
@@ -3469,10 +3507,14 @@ def run_agent_chat(cfg):
                 client.put_object(Bucket=bucket, Key=f"{base}/manifest.json",
                                   Body=json.dumps(manifest).encode("utf-8"),
                                   ContentType="application/json")
-                return (f"Indexed {files} files into {len(records)} chunks for {source_url}. "
-                        f"Use rag_search(source_url='{source_url}', query=...) to retrieve, then answer the user.")
+                out = (f"Indexed {files} files into {len(records)} chunks for {source_url}. "
+                       f"Use rag_search(source_url='{source_url}', query=...) to retrieve, then answer the user.")
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: indexing failed: {type(e).__name__}: {e}"
+                msg = f"Error: indexing failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def rag_add(source_url: str, text: str) -> str:
@@ -3483,9 +3525,13 @@ def run_agent_chat(cfg):
                 text: the new information to embed and store.
             """
             if not _RAG_AVAILABLE:
-                return "Error: RAG is not configured."
+                msg = "Error: RAG is not configured."
+                _last_obs["text"] = msg
+                return msg
             if not (text or "").strip():
-                return "Error: no text to add."
+                msg = "Error: no text to add."
+                _last_obs["text"] = msg
+                return msg
             _emit({"type": "step", "text": f"RAG source → {source_url}"})
             _emit({"type": "step", "text": "Adding info to RAG…"})
             try:
@@ -3499,9 +3545,13 @@ def run_agent_chat(cfg):
                 shard = f"{base}/chunks-add-{int(_t.time())}.jsonl"
                 body = "\n".join(json.dumps(r, ensure_ascii=False) for r in records).encode("utf-8")
                 client.put_object(Bucket=bucket, Key=shard, Body=body, ContentType="application/x-ndjson")
-                return f"Added {len(records)} chunk(s) to the knowledge base for {source_url}."
+                out = f"Added {len(records)} chunk(s) to the knowledge base for {source_url}."
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: rag_add failed: {type(e).__name__}: {e}"
+                msg = f"Error: rag_add failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def rag_search(source_url: str, query: str, k: int = 0) -> str:
@@ -3513,7 +3563,9 @@ def run_agent_chat(cfg):
                 k: number of chunks to return (0 = configured default).
             """
             if not _RAG_AVAILABLE:
-                return "Error: RAG is not configured."
+                msg = "Error: RAG is not configured."
+                _last_obs["text"] = msg
+                return msg
             _emit({"type": "step", "text": f"RAG source → {source_url}"})
             _emit({"type": "step", "text": f"Searching RAG → {query[:60]}"})
             try:
@@ -3521,7 +3573,9 @@ def run_agent_chat(cfg):
                 base = _rag_prefix_for(source_url, prefix)
                 chunks = _rag_load_chunks(client, bucket, base)
                 if not chunks:
-                    return f"No knowledge base found for {source_url}. Run rag_index first."
+                    msg = f"No knowledge base found for {source_url}. Run rag_index first."
+                    _last_obs["text"] = msg
+                    return msg
                 qvec = _embed(rag_embed_base, rag_embed_model, [query])[0]
                 scored = sorted(
                     ((_cosine(qvec, c.get("embedding") or []), c) for c in chunks),
@@ -3530,9 +3584,13 @@ def run_agent_chat(cfg):
                 topk = scored[: (k if k and k > 0 else rag_top_k)]
                 parts = [f"[{c.get('file', '?')}] (score {score:.2f})\n{c.get('text', '')}"
                          for score, c in topk]
-                return "\n\n---\n\n".join(parts) if parts else "No matches."
+                out = "\n\n---\n\n".join(parts) if parts else "No matches."
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: rag_search failed: {type(e).__name__}: {e}"
+                msg = f"Error: rag_search failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def grep_repo(pattern: str, path: str = "", glob: str = "") -> str:
@@ -3573,11 +3631,17 @@ def run_agent_chat(cfg):
                         break
                 _emit({"type": "step", "text": f"Searching code → {pattern[:60]} ({len(hits)} hits)"})
                 if not hits:
-                    return f"No matches for {pattern!r} under {root}."
+                    msg = f"No matches for {pattern!r} under {root}."
+                    _last_obs["text"] = msg
+                    return msg
                 more = "\n…(capped at 100 hits)" if len(hits) >= 100 else ""
-                return f"Matches under {root}:\n" + "\n".join(hits) + more
+                out = f"Matches under {root}:\n" + "\n".join(hits) + more
+                _last_obs["text"] = out
+                return out
             except Exception as e:  # noqa: BLE001
-                return f"Error: grep_repo failed: {type(e).__name__}: {e}"
+                msg = f"Error: grep_repo failed: {type(e).__name__}: {e}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def read_file_lines(path: str, start_line: int = 1, end_line: int = 0) -> str:
@@ -3596,9 +3660,13 @@ def run_agent_chat(cfg):
                 e = int(end_line or 0) or len(lines)
                 e = min(e, len(lines), s + 399)
                 body = "".join(f"{i}: {lines[i - 1]}" for i in range(s, e + 1))
-                return f"{rp} (lines {s}-{e} of {len(lines)}):\n{body}"
+                out = f"{rp} (lines {s}-{e} of {len(lines)}):\n{body}"
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                return f"Error: read_file_lines failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: read_file_lines failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def edit_lines(path: str, start_line: int, end_line: int, new_content: str) -> str:
@@ -3614,14 +3682,18 @@ def run_agent_chat(cfg):
                 rp = _ws_write_allowed((path or "").strip())
                 import os
                 if not os.path.isfile(rp):
-                    return f"Error: not a file: {path}"
+                    msg = f"Error: not a file: {path}"
+                    _last_obs["text"] = msg
+                    return msg
                 backup = _ws_snapshot(rp)
                 with open(rp, "r", encoding="utf-8", errors="replace") as fh:
                     lines = fh.readlines()
                 s, e = int(start_line), int(end_line)
                 if not (1 <= s <= e <= len(lines)):
-                    return (f"Error: line range {s}-{e} is out of bounds "
-                            f"(file has {len(lines)} lines). Re-check with read_file_lines.")
+                    msg = (f"Error: line range {s}-{e} is out of bounds "
+                           f"(file has {len(lines)} lines). Re-check with read_file_lines.")
+                    _last_obs["text"] = msg
+                    return msg
                 new_lines = new_content.splitlines(keepends=True)
                 if new_lines and not new_lines[-1].endswith("\n"):
                     new_lines[-1] += "\n"
@@ -3632,10 +3704,14 @@ def run_agent_chat(cfg):
                 _emit({"type": "step", "text": f"Edited {os.path.basename(rp)} lines {s}-{e}"})
                 shown = "".join(f"{i}: {lines[i - 1]}" for i in
                                 range(max(1, s - 2), min(len(lines), s + len(new_lines) + 1) + 1))
-                return (f"Replaced lines {s}-{e} of {rp} with {len(new_lines)} line(s). "
-                        f"Backup saved. Updated region:\n{shown}")
+                out = (f"Replaced lines {s}-{e} of {rp} with {len(new_lines)} line(s). "
+                       f"Backup saved. Updated region:\n{shown}")
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                return f"Error: edit_lines failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: edit_lines failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def edit_file(path: str, old_string: str, new_string: str) -> str:
@@ -3650,23 +3726,33 @@ def run_agent_chat(cfg):
                 rp = _ws_write_allowed((path or "").strip())
                 import os
                 if not os.path.isfile(rp):
-                    return f"Error: not a file: {path}"
+                    msg = f"Error: not a file: {path}"
+                    _last_obs["text"] = msg
+                    return msg
                 with open(rp, "r", encoding="utf-8", errors="replace") as fh:
                     text = fh.read()
                 n = text.count(old_string)
                 if n == 0:
-                    return ("Error: old_string not found — it must match EXACTLY "
-                            "(check whitespace with read_file_lines, or use edit_lines).")
+                    msg = ("Error: old_string not found — it must match EXACTLY "
+                           "(check whitespace with read_file_lines, or use edit_lines).")
+                    _last_obs["text"] = msg
+                    return msg
                 if n > 1:
-                    return f"Error: old_string occurs {n} times — add surrounding context to make it unique, or use edit_lines."
+                    msg = f"Error: old_string occurs {n} times — add surrounding context to make it unique, or use edit_lines."
+                    _last_obs["text"] = msg
+                    return msg
                 backup = _ws_snapshot(rp)
                 with open(rp, "w", encoding="utf-8") as fh:
                     fh.write(text.replace(old_string, new_string, 1))
                 _ws_record_change("edit", rp, backup)
                 _emit({"type": "step", "text": f"Edited {os.path.basename(rp)}"})
-                return f"Replaced 1 occurrence in {rp}. Backup saved."
+                out = f"Replaced 1 occurrence in {rp}. Backup saved."
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                return f"Error: edit_file failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: edit_file failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def create_file(path: str, content: str) -> str:
@@ -3680,15 +3766,21 @@ def run_agent_chat(cfg):
                 rp = _ws_write_allowed((path or "").strip())
                 import os
                 if os.path.exists(rp):
-                    return f"Error: {path} already exists — use edit_lines/edit_file to change it."
+                    msg = f"Error: {path} already exists — use edit_lines/edit_file to change it."
+                    _last_obs["text"] = msg
+                    return msg
                 os.makedirs(os.path.dirname(rp) or ".", exist_ok=True)
                 with open(rp, "w", encoding="utf-8") as fh:
                     fh.write(content)
                 _ws_record_change("create", rp, None)
                 _emit({"type": "step", "text": f"Created {os.path.basename(rp)}"})
-                return f"Created {rp} ({len(content)} chars)."
+                out = f"Created {rp} ({len(content)} chars)."
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                return f"Error: create_file failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: create_file failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         @tool
         def run_command(command: str, workdir: str = "", timeout_seconds: int = 180) -> str:
@@ -3706,14 +3798,20 @@ def run_agent_chat(cfg):
                 wd = _rag_read_allowed((workdir or "").strip() or (_WS_ROOTS[0]["path"] if _WS_ROOTS else "."))
                 w = _ws_for_path(wd)
                 if w is None or not w.get("allowRun"):
-                    return ("Error: running commands is not enabled for this workspace. "
-                            "Re-register it with: gonext-local-worker workspace add <path> --allow-run")
+                    msg = ("Error: running commands is not enabled for this workspace. "
+                           "Re-register it with: gonext-local-worker workspace add <path> --allow-run")
+                    _last_obs["text"] = msg
+                    return msg
                 argv = shlex.split(command or "")
                 if not argv:
-                    return "Error: empty command."
+                    msg = "Error: empty command."
+                    _last_obs["text"] = msg
+                    return msg
                 if argv[0] not in _WS_RUN_ALLOWED:
-                    return (f"Error: '{argv[0]}' is not an allowed runner. Allowed: "
-                            + ", ".join(sorted(_WS_RUN_ALLOWED)))
+                    msg = (f"Error: '{argv[0]}' is not an allowed runner. Allowed: "
+                           + ", ".join(sorted(_WS_RUN_ALLOWED)))
+                    _last_obs["text"] = msg
+                    return msg
                 _emit({"type": "step", "text": f"Running → {command[:70]}"})
                 t = max(5, min(int(timeout_seconds or 180), 600))
                 # Scrubbed env: repo test scripts must never see worker secrets.
@@ -3724,11 +3822,17 @@ def run_agent_chat(cfg):
                 out = _ws_distill_output(proc.stdout or "")
                 status = "PASSED (exit 0)" if proc.returncode == 0 else f"FAILED (exit {proc.returncode})"
                 _emit({"type": "step", "text": f"Command {status.split()[0].lower()} → {command[:50]}"})
-                return f"{status}\n{out}" if out.strip() else status
+                result = f"{status}\n{out}" if out.strip() else status
+                _last_obs["text"] = result
+                return result
             except subprocess.TimeoutExpired:
-                return f"Error: command timed out after {timeout_seconds}s."
+                msg = f"Error: command timed out after {timeout_seconds}s."
+                _last_obs["text"] = msg
+                return msg
             except Exception as ex:  # noqa: BLE001
-                return f"Error: run_command failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: run_command failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
 
         agent_tools = [http_request, web_search, fetch_url, calculate,
                        get_current_datetime, create_pdf]
@@ -3825,7 +3929,19 @@ def run_agent_chat(cfg):
             # a fabricated "final" answer here instead would poison every future turn's
             # prompt with raw exception text (this is exactly what caused task #35).
             raise e
-        _emit({"type": "final", "text": fallback})
+        # _plain_reply has NO tool/file/HTTP access whatsoever — that's by design (it's a
+        # bare chat completion). Without a note here, its honest "I don't have access to
+        # your workspace/that page/etc." reads to the user as a PERMISSIONS bug, when the
+        # real cause is that the tool-capable agent loop failed upstream (e.g. the coding
+        # model timed out) and we silently swapped in a capability-limited fallback. Make
+        # that swap visible so the user can tell "genuinely no access" apart from
+        # "the real attempt never got to run" (seen live: workspace summarize request →
+        # coding model timed out 3x on a slow/unreachable remote Ollama box → silent
+        # fallback claimed "no access to your workspace").
+        _emit({"type": "final", "text": (
+            f"⚠️ I couldn't finish the full investigation ({_clip(str(e), 120)}) — here's "
+            f"what I can say without it:\n\n{fallback}"
+        )})
 
 
 def _log(text: str):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.192",
+  "version": "1.0.194",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",