opensteer 0.5.5 → 0.5.6

package/CHANGELOG.md

@@ -27,6 +27,8 @@
 - Cloud mode now falls back to `OPENSTEER_API_KEY` when `cloud.apiKey` is omitted.
 - Added automatic `.env` loading from `storage.rootDir` (default `process.cwd()`) so constructor config can consume env vars without requiring `import 'dotenv/config'`.
 - `.env` autoload follows common precedence (`.env.<NODE_ENV>.local`, `.env.local`, `.env.<NODE_ENV>`, `.env`) with `.env.local` skipped in `test`, does not overwrite existing env values, and can be disabled via `OPENSTEER_DISABLE_DOTENV_AUTOLOAD`.
+- Opensteer now reuses one resolved runtime env snapshot for config, CUA provider key resolution, and built-in AI resolve/extract provider setup; dotenv loading still does not mutate global `process.env`.
+- AI helper exports now accept optional `env` maps (`getModelProvider`, `createResolveCallback`, `createExtractCallback`) for deterministic provider initialization without relying on ambient process env state.
 - Mutating actions now include smart best-effort post-action wait with per-action
   profiles and optional per-call overrides via `wait`.
 - Added structured interaction diagnostics via `OpensteerActionError` for

package/dist/{chunk-YIQDOALV.js → chunk-AVXUMEDG.js}

@@ -5,12 +5,13 @@ import {
   buildExtractSystemPrompt,
   buildExtractUserPrompt,
   getModelProvider
-} from "./chunk-QHZFY3ZK.js";
+} from "./chunk-FAHE5DB2.js";
 
 // src/ai/extractor.ts
 function createExtractCallback(model, options) {
   const temperature = options?.temperature ?? 1;
   const maxTokens = options?.maxTokens ?? null;
+  const env = options?.env;
   return async (args) => {
     let generateText;
     try {
@@ -21,7 +22,7 @@ function createExtractCallback(model, options) {
         `To use AI extraction with model '${model}', install 'ai' with your package manager.`
       );
     }
-    const modelProvider = await getModelProvider(model);
+    const modelProvider = await getModelProvider(model, { env });
     const request = {
       model: modelProvider,
       system: buildExtractSystemPrompt(),

package/dist/{chunk-SPHS6YWD.js → chunk-DN3GI5CH.js}

@@ -2,12 +2,13 @@ import {
   buildResolveSystemPrompt,
   buildResolveUserPrompt,
   getModelProvider
-} from "./chunk-QHZFY3ZK.js";
+} from "./chunk-FAHE5DB2.js";
 
 // src/ai/resolver.ts
 function createResolveCallback(model, options) {
   const temperature = options?.temperature ?? 1;
   const maxTokens = options?.maxTokens ?? null;
+  const env = options?.env;
   return async (args) => {
     let generateObject;
     let z;
@@ -26,7 +27,7 @@ function createResolveCallback(model, options) {
         `To use AI resolution with model '${model}', install 'zod' with your package manager.`
       );
     }
-    const modelProvider = await getModelProvider(model);
+    const modelProvider = await getModelProvider(model, { env });
     const schema = z.object({
       element: z.number().describe(
         "Counter number of the matching element, or -1 if no match"

package/dist/{chunk-QHZFY3ZK.js → chunk-FAHE5DB2.js}

@@ -1,17 +1,49 @@
 // src/ai/model.ts
+var OPENAI_PROVIDER_INFO = {
+  pkg: "@ai-sdk/openai",
+  providerFn: "openai",
+  factoryFn: "createOpenAI",
+  apiKeyEnvVar: "OPENAI_API_KEY",
+  baseUrlEnvVar: "OPENAI_BASE_URL"
+};
+var ANTHROPIC_PROVIDER_INFO = {
+  pkg: "@ai-sdk/anthropic",
+  providerFn: "anthropic",
+  factoryFn: "createAnthropic",
+  apiKeyEnvVar: "ANTHROPIC_API_KEY",
+  baseUrlEnvVar: "ANTHROPIC_BASE_URL"
+};
+var GOOGLE_PROVIDER_INFO = {
+  pkg: "@ai-sdk/google",
+  providerFn: "google",
+  factoryFn: "createGoogleGenerativeAI",
+  apiKeyEnvVar: "GOOGLE_GENERATIVE_AI_API_KEY"
+};
+var XAI_PROVIDER_INFO = {
+  pkg: "@ai-sdk/xai",
+  providerFn: "xai",
+  factoryFn: "createXai",
+  apiKeyEnvVar: "XAI_API_KEY"
+};
+var GROQ_PROVIDER_INFO = {
+  pkg: "@ai-sdk/groq",
+  providerFn: "groq",
+  factoryFn: "createGroq",
+  apiKeyEnvVar: "GROQ_API_KEY"
+};
 var PROVIDER_MAP = {
-  "openai/": { pkg: "@ai-sdk/openai", providerFn: "openai" },
-  "anthropic/": { pkg: "@ai-sdk/anthropic", providerFn: "anthropic" },
-  "google/": { pkg: "@ai-sdk/google", providerFn: "google" },
-  "xai/": { pkg: "@ai-sdk/xai", providerFn: "xai" },
-  "gpt-": { pkg: "@ai-sdk/openai", providerFn: "openai" },
-  "o1-": { pkg: "@ai-sdk/openai", providerFn: "openai" },
-  "o3-": { pkg: "@ai-sdk/openai", providerFn: "openai" },
-  "o4-": { pkg: "@ai-sdk/openai", providerFn: "openai" },
-  "claude-": { pkg: "@ai-sdk/anthropic", providerFn: "anthropic" },
-  "gemini-": { pkg: "@ai-sdk/google", providerFn: "google" },
-  "grok-": { pkg: "@ai-sdk/xai", providerFn: "xai" },
-  "groq/": { pkg: "@ai-sdk/groq", providerFn: "groq" }
+  "openai/": OPENAI_PROVIDER_INFO,
+  "anthropic/": ANTHROPIC_PROVIDER_INFO,
+  "google/": GOOGLE_PROVIDER_INFO,
+  "xai/": XAI_PROVIDER_INFO,
+  "gpt-": OPENAI_PROVIDER_INFO,
+  "o1-": OPENAI_PROVIDER_INFO,
+  "o3-": OPENAI_PROVIDER_INFO,
+  "o4-": OPENAI_PROVIDER_INFO,
+  "claude-": ANTHROPIC_PROVIDER_INFO,
+  "gemini-": GOOGLE_PROVIDER_INFO,
+  "grok-": XAI_PROVIDER_INFO,
+  "groq/": GROQ_PROVIDER_INFO
 };
 function resolveProviderInfo(modelStr) {
   for (const [prefix, info] of Object.entries(PROVIDER_MAP)) {
@@ -28,7 +60,7 @@ function resolveProviderInfo(modelStr) {
       );
     }
   }
-  return { pkg: "@ai-sdk/openai", providerFn: "openai" };
+  return OPENAI_PROVIDER_INFO;
 }
 function stripProviderPrefix(modelStr) {
   const slash = modelStr.indexOf("/");
@@ -39,23 +71,50 @@ function stripProviderPrefix(modelStr) {
   }
   return modelStr;
 }
-async function getModelProvider(modelStr) {
-  const { pkg, providerFn } = resolveProviderInfo(modelStr);
+function normalizeEnvValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : void 0;
+}
+function buildFactoryOptions(provider, env) {
+  const apiKey = normalizeEnvValue(env[provider.apiKeyEnvVar]);
+  if (!apiKey) {
+    throw new Error(
+      `API key is missing in the resolved Opensteer environment. Set ${provider.apiKeyEnvVar} in your runtime environment or .env file under storage.rootDir.`
+    );
+  }
+  const baseURL = provider.baseUrlEnvVar ? normalizeEnvValue(env[provider.baseUrlEnvVar]) : void 0;
+  return {
+    apiKey,
+    ...baseURL ? { baseURL } : {}
+  };
+}
+async function getModelProvider(modelStr, options = {}) {
+  const info = resolveProviderInfo(modelStr);
   let mod;
   try {
-    mod = await import(pkg);
+    mod = await import(info.pkg);
   } catch {
     throw new Error(
-      `To use AI resolution with model '${modelStr}', install 'ai' and '${pkg}' with your package manager.`
+      `To use AI resolution with model '${modelStr}', install 'ai' and '${info.pkg}' with your package manager.`
     );
   }
-  const provider = mod[providerFn];
-  if (typeof provider !== "function") {
+  const providerExportName = options.env ? info.factoryFn : info.providerFn;
+  const providerExport = mod[providerExportName];
+  if (typeof providerExport !== "function") {
     throw new Error(
-      `Provider '${providerFn}' not found in '${pkg}'. Ensure you have the latest version installed.`
+      `Provider '${providerExportName}' not found in '${info.pkg}'. Ensure you have the latest version installed.`
     );
   }
   const modelId = stripProviderPrefix(modelStr);
+  const provider = options.env != null ? providerExport(
+    buildFactoryOptions(info, options.env)
+  ) : providerExport;
+  if (typeof provider !== "function") {
+    throw new Error(
+      `Provider '${providerExportName}' from '${info.pkg}' did not return a model factory function.`
+    );
+  }
   return provider(modelId);
 }
 

package/dist/{chunk-XIH3WGPY.js → chunk-SGZYTGY3.js}

@@ -8196,7 +8196,7 @@ function resolveCloudSelection(config, env = process.env) {
     source: "default"
   };
 }
-function resolveConfig(input = {}) {
+function resolveConfigWithEnv(input = {}) {
   const processEnv = process.env;
   const debugHint = typeof input.debug === "boolean" ? input.debug : parseBool(processEnv.OPENSTEER_DEBUG) === true;
   const initialRootDir = input.storage?.rootDir ?? process.cwd();
@@ -8289,7 +8289,10 @@ function resolveConfig(input = {}) {
       baseUrl: envBaseUrl
     };
   }
-  return resolved;
+  return {
+    config: resolved,
+    env
+  };
 }
 function resolveNamespace(config, rootDir) {
   if (config.name && config.name.trim()) {
@@ -9036,7 +9039,9 @@ function minimizePathMatchClauses(path5, mode) {
       (clause) => clause?.kind === "position"
     );
     let keptPositions = [];
-    if (!attrClauses.length) {
+    if (mode === "field") {
+      keptPositions = pickMinimalPositionClauses(positionClauses);
+    } else if (!attrClauses.length) {
       keptPositions = pickMinimalPositionClauses(positionClauses);
     } else if (mode === "item-root" && !isLast) {
       keptPositions = [];
@@ -9130,7 +9135,7 @@ function relaxPathForSingleSample(path5, mode) {
     const match = (node.match || []).filter((clause) => {
       if (!clause || typeof clause !== "object") return false;
       if (clause.kind === "position") {
-        if (mode === "field") return false;
+        if (mode === "field") return true;
         return !isLast;
       }
       const key = String(clause.key || "").trim().toLowerCase();
@@ -9681,6 +9686,196 @@ function clonePersistedExtractNode(node) {
   return JSON.parse(JSON.stringify(node));
 }
 
+// src/extraction/array-field-validation.ts
+async function stripRedundantPositionClauses(payload, page) {
+  const cloned = structuredClone(payload);
+  await processObjectNode(cloned, page);
+  return cloned;
+}
+async function processNode(node, page) {
+  if (isPersistedArrayNode(node)) {
+    await processArrayNode(node, page);
+    return;
+  }
+  if (isPersistedObjectNode(node)) {
+    await processObjectNode(node, page);
+  }
+}
+async function processObjectNode(node, page) {
+  for (const child of Object.values(node)) {
+    await processNode(child, page);
+  }
+}
+async function processArrayNode(node, page) {
+  for (const variant of node.$array.variants) {
+    try {
+      await pruneVariantPositions(variant, page);
+    } catch {
+    }
+    await processNode(variant.item, page);
+  }
+}
+function collectValueNodes(node) {
+  if (isPersistedValueNode(node)) {
+    return [
+      {
+        path: node.$path,
+        replacePath(path5) {
+          node.$path = path5;
+        }
+      }
+    ];
+  }
+  if (!isPersistedObjectNode(node)) return [];
+  const refs = [];
+  const visit = (current) => {
+    for (const [key, child] of Object.entries(current)) {
+      if (isPersistedValueNode(child)) {
+        refs.push({
+          path: child.$path,
+          replacePath(path5) {
+            const next = current[key];
+            if (!isPersistedValueNode(next)) return;
+            next.$path = path5;
+          }
+        });
+        continue;
+      }
+      if (isPersistedObjectNode(child)) {
+        visit(child);
+      }
+    }
+  };
+  visit(node);
+  return refs;
+}
+function hasPositionClause(path5) {
+  return path5.nodes.some(
+    (node) => (node.match || []).some((clause) => clause.kind === "position")
+  );
+}
+function areArraysEqual(left, right) {
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i++) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
+async function pruneVariantPositions(variant, page) {
+  const refs = collectValueNodes(variant.item).filter(
+    (ref) => hasPositionClause(ref.path)
+  );
+  if (!refs.length) return;
+  const plans = refs.map((ref, index) => {
+    const withPos = buildArrayFieldPathCandidates(ref.path);
+    const strippedPath = stripPositionClauses2(ref.path);
+    const withoutPos = buildArrayFieldPathCandidates(strippedPath);
+    if (areArraysEqual(withPos, withoutPos)) return null;
+    const plan = {
+      key: String(index),
+      strippedPath,
+      replacePath: ref.replacePath,
+      selectors: {
+        withPos,
+        withoutPos
+      }
+    };
+    return plan;
+  }).filter((plan) => !!plan);
+  if (!plans.length) return;
+  const selectorMap = {};
+  for (const plan of plans) {
+    selectorMap[plan.key] = plan.selectors;
+  }
+  const validatedKeys = new Set(plans.map((plan) => plan.key));
+  const items = await queryAllByElementPath(page, variant.itemParentPath);
+  if (!items.length) return;
+  try {
+    for (const item of items) {
+      const results = await validateRowSelectors(item, selectorMap);
+      const failedKeys = [];
+      for (const key of validatedKeys) {
+        if (results[key] === true) continue;
+        failedKeys.push(key);
+      }
+      for (const key of failedKeys) {
+        validatedKeys.delete(key);
+      }
+      if (!validatedKeys.size) break;
+    }
+  } finally {
+    await Promise.all(
+      items.map(async (item) => {
+        try {
+          await item.dispose();
+        } catch {
+        }
+      })
+    );
+  }
+  for (const plan of plans) {
+    if (!validatedKeys.has(plan.key)) continue;
+    plan.replacePath(plan.strippedPath);
+  }
+}
+async function validateRowSelectors(item, fields) {
+  return item.evaluate((element, selectorMap) => {
+    const tryFirst = (root, selectors) => {
+      let fallback = null;
+      for (const selector of selectors) {
+        if (!selector) continue;
+        let matches = [];
+        try {
+          matches = Array.from(root.querySelectorAll(selector));
+        } catch {
+          matches = [];
+        }
+        if (!matches.length) continue;
+        if (matches.length === 1) {
+          return matches[0];
+        }
+        if (!fallback) {
+          fallback = matches[0];
+        }
+      }
+      return fallback;
+    };
+    const out = {};
+    for (const [key, selectors] of Object.entries(selectorMap)) {
+      const original = tryFirst(element, selectors.withPos);
+      if (!original) {
+        out[key] = false;
+        continue;
+      }
+      let strippedUnique = null;
+      for (const selector of selectors.withoutPos) {
+        if (!selector) continue;
+        let matches = [];
+        try {
+          matches = Array.from(element.querySelectorAll(selector));
+        } catch {
+          matches = [];
+        }
+        if (matches.length === 1) {
+          strippedUnique = matches[0];
+          break;
+        }
+      }
+      out[key] = strippedUnique === original;
+    }
+    return out;
+  }, fields);
+}
+function stripPositionClauses2(path5) {
+  return {
+    context: path5.context,
+    nodes: path5.nodes.map((node) => ({
+      ...node,
+      match: (node.match || []).filter((clause) => clause.kind !== "position")
+    }))
+  };
+}
+
 // src/cloud/runtime.ts
 var DEFAULT_CLOUD_BASE_URL = "https://api.opensteer.com";
 function createCloudRuntimeState(key, baseUrl = resolveCloudBaseUrl(), authScheme = "api-key") {
@@ -9727,6 +9922,7 @@ var CLOUD_INTERACTION_METHODS = /* @__PURE__ */ new Set([
 ]);
 var Opensteer = class _Opensteer {
   config;
+  runtimeEnv;
   aiResolve;
   aiExtract;
   namespace;
@@ -9740,14 +9936,17 @@ var Opensteer = class _Opensteer {
   snapshotCache = null;
   agentExecutionInFlight = false;
   constructor(config = {}) {
-    const resolved = resolveConfig(config);
+    const resolvedRuntime = resolveConfigWithEnv(config);
+    const resolved = resolvedRuntime.config;
+    const runtimeEnv = resolvedRuntime.env;
     const cloudSelection = resolveCloudSelection({
       cloud: resolved.cloud
-    });
+    }, runtimeEnv);
     const model = resolved.model;
     this.config = resolved;
-    this.aiResolve = this.createLazyResolveCallback(model);
-    this.aiExtract = this.createLazyExtractCallback(model);
+    this.runtimeEnv = runtimeEnv;
+    this.aiResolve = this.createLazyResolveCallback(model, runtimeEnv);
+    this.aiExtract = this.createLazyExtractCallback(model, runtimeEnv);
     const rootDir = resolved.storage?.rootDir || process.cwd();
     this.namespace = resolveNamespace(resolved, rootDir);
     this.storage = new LocalSelectorStorage(rootDir, this.namespace, {
@@ -9779,13 +9978,13 @@ var Opensteer = class _Opensteer {
       `[opensteer] ${context}: ${normalized.message}${codeSuffix}`
     );
   }
-  createLazyResolveCallback(model) {
+  createLazyResolveCallback(model, env) {
     let resolverPromise = null;
     return async (...args) => {
       try {
         if (!resolverPromise) {
-          resolverPromise = import("./resolver-ZREUOOTV.js").then(
-            (m) => m.createResolveCallback(model)
+          resolverPromise = import("./resolver-MGN64KCP.js").then(
+            (m) => m.createResolveCallback(model, { env })
           );
         }
         const resolver = await resolverPromise;
@@ -9796,13 +9995,13 @@ var Opensteer = class _Opensteer {
       }
     };
   }
-  createLazyExtractCallback(model) {
+  createLazyExtractCallback(model, env) {
     let extractorPromise = null;
     const extract = async (args) => {
       try {
         if (!extractorPromise) {
-          extractorPromise = import("./extractor-CZFCFUME.js").then(
-            (m) => m.createExtractCallback(model)
+          extractorPromise = import("./extractor-4Q3TFZJB.js").then(
+            (m) => m.createExtractCallback(model, { env })
           );
         }
         const extractor = await extractorPromise;
@@ -10079,10 +10278,11 @@ var Opensteer = class _Opensteer {
     this.snapshotCache = null;
   }
   static from(page, config = {}) {
-    const resolvedConfig = resolveConfig(config);
+    const resolvedRuntime = resolveConfigWithEnv(config);
+    const resolvedConfig = resolvedRuntime.config;
     const cloudSelection = resolveCloudSelection({
       cloud: resolvedConfig.cloud
-    });
+    }, resolvedRuntime.env);
     if (cloudSelection.cloud) {
       throw cloudUnsupportedMethodError(
         "Opensteer.from(page)",
@@ -11057,7 +11257,7 @@ var Opensteer = class _Opensteer {
     const data = await this.extractFields(fields);
     if (storageKey && schemaHash && (!stored || stored.schemaHash !== schemaHash)) {
       const persistedFields = await this.resolveFieldTargetsToPersistableFields(fields);
-      this.persistExtractPaths(
+      await this.persistExtractPaths(
         storageKey,
         options.description,
         persistedFields,
@@ -11091,13 +11291,12 @@ var Opensteer = class _Opensteer {
     const resolvedFields = await this.resolveFieldTargetsToPersistableFields(fields);
     let persisted = false;
     if (storageKey) {
-      this.persistExtractPaths(
+      persisted = await this.persistExtractPaths(
         storageKey,
         options.description,
         resolvedFields,
         schemaHash
       );
-      persisted = true;
     }
     return {
       namespace: this.storage.getNamespace(),
@@ -11129,7 +11328,8 @@ var Opensteer = class _Opensteer {
   agent(config) {
     const resolvedAgentConfig = resolveAgentConfig({
       agentConfig: config,
-      fallbackModel: this.config.model
+      fallbackModel: this.config.model,
+      env: this.runtimeEnv
     });
     return {
       execute: async (instructionOrOptions) => {
@@ -11558,7 +11758,7 @@ var Opensteer = class _Opensteer {
     this.storage.saveRegistry(registry);
     return true;
   }
-  persistExtractPaths(id, description, fields, schemaHash) {
+  async persistExtractPaths(id, description, fields, schemaHash) {
     const now = Date.now();
     const safeFile = this.storage.getSelectorFileName(id);
     const existing = this.storage.readSelector(id);
@@ -11579,11 +11779,19 @@ var Opensteer = class _Opensteer {
       }
     );
     const persistedPayload = buildPersistedExtractPayload(normalizedFields);
+    let validatedPayload = persistedPayload;
+    try {
+      validatedPayload = await stripRedundantPositionClauses(
+        persistedPayload,
+        this.page
+      );
+    } catch {
+    }
     const payload = {
       id,
       method: "extract",
       description: description || "Extraction paths",
-      path: persistedPayload,
+      path: validatedPayload,
       schemaHash,
       metadata: {
         createdAt,
@@ -12282,6 +12490,8 @@ export {
   extractArrayWithPaths,
   extractArrayRowsWithPaths,
   countArrayItemsWithPath,
+  queryAllByElementPath,
+  buildArrayFieldPathCandidates,
   listTabs,
   createTab,
   switchTab,