@lazyingart/agintiflow 0.20.133 → 0.20.135

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.133",
+  "version": "0.20.135",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/references/agintiflow-aaps-slogan-subtext-v3.md

@@ -14,7 +14,7 @@ AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-a
 
 Project-oriented programming for agentic workflows.
 
-AAPS is a prompt-native programming language and visual studio for turning prompts into structured, verifiable pipelines. It connects wet and dry experiments, hardware and software, and human intent with executable agent work through tasks, typed inputs, declared outputs, validation gates, recovery steps, and durable artifacts.
+AAPS is a project oriented and prompt-native programming language and visual studio for turning prompts into structured, verifiable pipelines. It connects wet and dry experiments, hardware and software, and human intent with executable agent work through tasks, typed inputs, declared outputs, validation gates, recovery steps, and durable artifacts.
 
 ## Shorter Version
 

package/scripts/smoke-auth.js

@@ -66,9 +66,25 @@ try {
   const veniceDefaults = getProviderDefaults("venice");
   assert(veniceDefaults.provider === "venice" && veniceDefaults.model === "venice-uncensored-1-2", "venice provider defaults are not available");
 
+  process.env.DEEPSEEK_API_KEY = "ambient-deepseek-key";
+  process.env.VENICE_API_KEY = "ambient-venice-key";
+  process.env.GRSAI_API_KEY = "ambient-grsai-key";
+  let status = providerKeyStatus(tempRoot);
+  assert(status.deepseek && status.venice && status.grsai, "ambient provider keys were not detected");
+  assert(status.localEnv, "ambient provider keys were not persisted into local .aginti/.env");
+  const localEnv = await fs.readFile(path.join(tempRoot, ".aginti", ".env"), "utf8");
+  assert(localEnv.includes("DEEPSEEK_API_KEY="), "ambient DeepSeek key was not saved locally");
+  assert(localEnv.includes("VENICE_API_KEY="), "ambient Venice key was not saved locally");
+  assert(localEnv.includes("GRSAI_API_KEY="), "ambient GRS AI key was not saved locally");
+  delete process.env.DEEPSEEK_API_KEY;
+  delete process.env.VENICE_API_KEY;
+  delete process.env.GRSAI_API_KEY;
+  status = providerKeyStatus(tempRoot);
+  assert(status.deepseek && status.venice && status.grsai, "persisted provider keys were not reloaded after ambient env was cleared");
+
   await setProviderKey(tempRoot, "qwen", "test-qwen-key");
   await setProviderKey(tempRoot, "venice", "test-venice-key");
-  let status = providerKeyStatus(tempRoot);
+  status = providerKeyStatus(tempRoot);
   assert(status.qwen, "qwen key status was not detected");
   assert(status.venice, "venice key status was not detected");
   assert(status.envVars.qwen.includes("QWEN_API_KEY"), "qwen env var name was not reported");
@@ -103,6 +119,7 @@ try {
           "provider-key-preview",
           "qwen-defaults",
           "venice-defaults",
+          "ambient-key-autopersist",
           "qwen-key-status",
           "venice-key-status",
           "cli-key-status-redacted",

package/scripts/smoke-model-roles.js

@@ -179,6 +179,12 @@ const multipleRequestedToolCalls = parseTextToolCalls(
 );
 assert(multipleRequestedToolCalls.length === 2, "Requested tools parser did not detect multiple function-call texts");
 assert(multipleRequestedToolCalls[1].function.name === "inspect_project", "Requested tools parser returned wrong second requested tool");
+const xmlTextToolCalls = parseTextToolCalls(
+  '<tool_calls>\n<tool_call name="inspect_project">{"project_path":"/workspace"}</tool_call>\n<tool_call name="list_files">{"path":".","depth":2}</tool_call>\n</tool_calls>'
+);
+assert(xmlTextToolCalls.length === 2, "XML text tool-call parser did not detect multiple calls");
+assert(xmlTextToolCalls[0].function.name === "inspect_project", "XML text tool-call parser returned wrong first tool");
+assert(xmlTextToolCalls[1].function.arguments.includes('"depth":2'), "XML text tool-call parser returned wrong arguments");
 const malformedRequestedToolResponse = normalizeTextToolCallResponse({
   choices: [
     {

package/src/model-client.js

@@ -204,6 +204,7 @@ export function parseTextToolCalls(content = "") {
 
   const calls = [];
   for (const call of parseRequestedToolCalls(text)) calls.push(call);
+  for (const call of parseXmlToolCalls(text, calls.length)) calls.push(call);
   const jsonBlock = text.match(/TOOL_CALLS\s*:\s*```(?:json)?\s*([\s\S]*?)```/i);
   if (jsonBlock?.[1]) {
     try {
@@ -258,7 +259,51 @@ export function parseTextToolCalls(content = "") {
 
 function hasTextToolCallMarker(content = "") {
   const text = String(content || "");
-  return text.includes("[TOOL_CALLS]") || /TOOL_CALLS\s*:/i.test(text) || /Requested tools?\s*:/i.test(text);
+  return (
+    text.includes("[TOOL_CALLS]") ||
+    /TOOL_CALLS\s*:/i.test(text) ||
+    /Requested tools?\s*:/i.test(text) ||
+    /<tool_calls?>/i.test(text)
+  );
+}
+
+function decodeXmlToolArgs(value = "") {
+  return String(value || "")
+    .trim()
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}
+
+function parseXmlToolCalls(content = "", offset = 0) {
+  const text = String(content || "");
+  const calls = [];
+  const pattern = /<tool_call\b([^>]*)>([\s\S]*?)<\/tool_call>/gi;
+  let match;
+  while ((match = pattern.exec(text))) {
+    const attrs = match[1] || "";
+    const name =
+      attrs.match(/\bname\s*=\s*"([^"]+)"/i)?.[1]?.trim() ||
+      attrs.match(/\bname\s*=\s*'([^']+)'/i)?.[1]?.trim();
+    if (!name) continue;
+    const rawArgs = decodeXmlToolArgs(match[2]);
+    try {
+      JSON.parse(rawArgs || "{}");
+    } catch {
+      continue;
+    }
+    calls.push({
+      id: `text-tool-${offset + calls.length + 1}`,
+      type: "function",
+      function: {
+        name,
+        arguments: rawArgs || "{}",
+      },
+    });
+  }
+  return calls;
 }
 
 function findMatchingParen(text = "", openIndex = 0) {
@@ -330,6 +375,7 @@ function textBeforeToolCallMarker(content = "") {
     .split("[TOOL_CALLS]")[0]
     .split("TOOL_CALLS:")[0]
     .split(/Requested tools?\s*:/i)[0]
+    .split(/<tool_calls?>/i)[0]
     .split("<|tool_call>")[0]
     .trim();
 }

package/src/project.js

@@ -51,6 +51,16 @@ const PROVIDER_KEY_CANDIDATES = {
   grsai: ["GRSAI", "GRSAI_API_KEY"],
 };
 
+const AMBIENT_PROVIDER_KEYS = [
+  "DEEPSEEK_API_KEY",
+  "OPENAI_API_KEY",
+  "QWEN_API_KEY",
+  "VENICE_API_KEY",
+  "GRSAI",
+  "GRSAI_API_KEY",
+  "LLM_API_KEY",
+];
+
 export function resolveProjectRoot(input = process.cwd()) {
   return path.resolve(input || process.cwd());
 }
@@ -206,6 +216,55 @@ export function parseEnvText(text = "") {
   return values;
 }
 
+function ensureSecretGitignoreLinesSync(gitignorePath) {
+  const lines = [".aginti/.env", ".aginti/.env.*", "!.aginti/.env.example"];
+  let current = "";
+  try {
+    current = fs.readFileSync(gitignorePath, "utf8");
+  } catch {
+    current = "";
+  }
+  const existing = new Set(current.split(/\r?\n/).map((line) => line.trim()));
+  const missing = lines.filter((line) => !existing.has(line));
+  if (missing.length === 0) return;
+  const prefix = current && !current.endsWith("\n") ? "\n" : "";
+  fs.writeFileSync(gitignorePath, `${current}${prefix}${missing.join("\n")}\n`, "utf8");
+}
+
+function persistAmbientProviderKeysSync(paths) {
+  let parsed = {};
+  try {
+    parsed = parseEnvText(fs.readFileSync(paths.envPath, "utf8"));
+  } catch {
+    parsed = {};
+  }
+
+  let changed = false;
+  const persistedKeys = [];
+  for (const keyName of AMBIENT_PROVIDER_KEYS) {
+    const value = String(process.env[keyName] || "").trim();
+    if (!value || parsed[keyName]) continue;
+    parsed[keyName] = value;
+    persistedKeys.push(keyName);
+    changed = true;
+  }
+  if (!changed) return { persisted: false, keys: [] };
+
+  fs.mkdirSync(paths.controlDir, { recursive: true });
+  ensureSecretGitignoreLinesSync(paths.gitignorePath);
+  const output = Object.entries(parsed)
+    .filter(([key]) => LOCAL_ENV_KEYS.has(key))
+    .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+    .join("\n");
+  fs.writeFileSync(paths.envPath, `${output}\n`, { mode: 0o600 });
+  try {
+    fs.chmodSync(paths.envPath, 0o600);
+  } catch {
+    // chmod can fail on non-POSIX filesystems; the file still remains local and gitignored.
+  }
+  return { persisted: true, keys: persistedKeys };
+}
+
 export function loadProjectEnv(projectRoot = process.cwd(), { override = false } = {}) {
   const paths = projectPaths(projectRoot);
   const envPaths = [paths.rootEnvPath, paths.envPath];
@@ -222,10 +281,14 @@ export function loadProjectEnv(projectRoot = process.cwd(), { override = false }
       // Ignore missing or unreadable optional local env files.
     }
   }
+  const ambient = persistAmbientProviderKeysSync(paths);
+  if (ambient.persisted && !loadedPaths.includes(paths.envPath)) loadedPaths.push(paths.envPath);
   return {
     loaded: loadedPaths.length > 0,
     path: paths.envPath,
     paths: loadedPaths,
+    ambientPersisted: ambient.persisted,
+    ambientKeys: ambient.keys,
   };
 }