opensteer 0.5.5 → 0.6.0

package/dist/cli/server.cjs

@@ -117,7 +117,7 @@ function resolveProviderInfo(modelStr) {
       );
     }
   }
-  return { pkg: "@ai-sdk/openai", providerFn: "openai" };
+  return OPENAI_PROVIDER_INFO;
 }
 function stripProviderPrefix(modelStr) {
   const slash = modelStr.indexOf("/");
@@ -128,42 +128,101 @@ 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);
 }
-var PROVIDER_MAP;
+var OPENAI_PROVIDER_INFO, ANTHROPIC_PROVIDER_INFO, GOOGLE_PROVIDER_INFO, XAI_PROVIDER_INFO, GROQ_PROVIDER_INFO, PROVIDER_MAP;
 var init_model = __esm({
   "src/ai/model.ts"() {
     "use strict";
+    OPENAI_PROVIDER_INFO = {
+      pkg: "@ai-sdk/openai",
+      providerFn: "openai",
+      factoryFn: "createOpenAI",
+      apiKeyEnvVar: "OPENAI_API_KEY",
+      baseUrlEnvVar: "OPENAI_BASE_URL"
+    };
+    ANTHROPIC_PROVIDER_INFO = {
+      pkg: "@ai-sdk/anthropic",
+      providerFn: "anthropic",
+      factoryFn: "createAnthropic",
+      apiKeyEnvVar: "ANTHROPIC_API_KEY",
+      baseUrlEnvVar: "ANTHROPIC_BASE_URL"
+    };
+    GOOGLE_PROVIDER_INFO = {
+      pkg: "@ai-sdk/google",
+      providerFn: "google",
+      factoryFn: "createGoogleGenerativeAI",
+      apiKeyEnvVar: "GOOGLE_GENERATIVE_AI_API_KEY"
+    };
+    XAI_PROVIDER_INFO = {
+      pkg: "@ai-sdk/xai",
+      providerFn: "xai",
+      factoryFn: "createXai",
+      apiKeyEnvVar: "XAI_API_KEY"
+    };
+    GROQ_PROVIDER_INFO = {
+      pkg: "@ai-sdk/groq",
+      providerFn: "groq",
+      factoryFn: "createGroq",
+      apiKeyEnvVar: "GROQ_API_KEY"
+    };
     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
     };
   }
 });
@@ -244,6 +303,7 @@ __export(resolver_exports, {
 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;
@@ -262,7 +322,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"
@@ -302,6 +362,7 @@ __export(extractor_exports, {
 function createExtractCallback(model, options) {
   const temperature = options?.temperature ?? 1;
   const maxTokens = options?.maxTokens ?? null;
+  const env = options?.env;
   return async (args) => {
     let generateText;
     try {
@@ -312,7 +373,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(),
@@ -1345,7 +1406,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();
@@ -1438,7 +1499,10 @@ function resolveConfig(input = {}) {
       baseUrl: envBaseUrl
     };
   }
-  return resolved;
+  return {
+    config: resolved,
+    env
+  };
 }
 function resolveNamespace(config, rootDir) {
   if (config.name && config.name.trim()) {
@@ -7033,7 +7097,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 = [];
@@ -7127,7 +7193,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();
@@ -7678,6 +7744,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/contracts.ts
 var cloudSessionContractVersion = "v3";
 
@@ -10080,6 +10336,7 @@ var CLOUD_INTERACTION_METHODS = /* @__PURE__ */ new Set([
 ]);
 var Opensteer = class _Opensteer {
   config;
+  runtimeEnv;
   aiResolve;
   aiExtract;
   namespace;
@@ -10093,14 +10350,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, {
@@ -10132,13 +10392,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 = Promise.resolve().then(() => (init_resolver(), resolver_exports)).then(
-            (m) => m.createResolveCallback(model)
+            (m) => m.createResolveCallback(model, { env })
           );
         }
         const resolver = await resolverPromise;
@@ -10149,13 +10409,13 @@ var Opensteer = class _Opensteer {
       }
     };
   }
-  createLazyExtractCallback(model) {
+  createLazyExtractCallback(model, env) {
     let extractorPromise = null;
     const extract = async (args) => {
       try {
         if (!extractorPromise) {
           extractorPromise = Promise.resolve().then(() => (init_extractor(), extractor_exports)).then(
-            (m) => m.createExtractCallback(model)
+            (m) => m.createExtractCallback(model, { env })
           );
         }
         const extractor = await extractorPromise;
@@ -10432,10 +10692,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)",
@@ -11410,7 +11671,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,
@@ -11444,13 +11705,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(),
@@ -11482,7 +11742,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) => {
@@ -11911,7 +12172,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);
@@ -11932,11 +12193,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,

package/dist/cli/server.js

@@ -1,7 +1,7 @@
 import {
   Opensteer,
   normalizeError
-} from "../chunk-XIH3WGPY.js";
+} from "../chunk-SGZYTGY3.js";
 import "../chunk-3H5RRIMZ.js";
 
 // src/cli/server.ts

package/dist/{extractor-CZFCFUME.js → extractor-4Q3TFZJB.js}

@@ -1,8 +1,8 @@
 import {
   createExtractCallback
-} from "./chunk-YIQDOALV.js";
+} from "./chunk-AVXUMEDG.js";
 import "./chunk-3H5RRIMZ.js";
-import "./chunk-QHZFY3ZK.js";
+import "./chunk-FAHE5DB2.js";
 export {
   createExtractCallback
 };