opensteer 0.1.0

package/dist/chunk-DQIHOUXH.js

@@ -0,0 +1,61 @@
+import {
+  flattenExtractionDataToFieldPlan
+} from "./chunk-3H5RRIMZ.js";
+import {
+  buildExtractSystemPrompt,
+  buildExtractUserPrompt,
+  getModelProvider
+} from "./chunk-L4FHT64T.js";
+
+// src/ai/extractor.ts
+function createExtractCallback(model, options) {
+  const temperature = options?.temperature ?? 1;
+  const maxTokens = options?.maxTokens ?? null;
+  return async (args) => {
+    let generateText;
+    try {
+      const aiMod = await import("ai");
+      generateText = aiMod.generateText;
+    } catch {
+      throw new Error(
+        `To use AI extraction with model '${model}', install 'ai' with your package manager.`
+      );
+    }
+    const modelProvider = await getModelProvider(model);
+    const request = {
+      model: modelProvider,
+      system: buildExtractSystemPrompt(),
+      prompt: buildExtractUserPrompt(args),
+      temperature,
+      ...maxTokens == null ? {} : { maxOutputTokens: maxTokens }
+    };
+    const result = await generateText(request);
+    const parsed = parseExtractResponse(result.text);
+    if (!parsed.contains_data) {
+      return { fields: {} };
+    }
+    const fields = flattenExtractionDataToFieldPlan(parsed.data);
+    return { fields };
+  };
+}
+function parseExtractResponse(text) {
+  const trimmed = text.trim();
+  const jsonStr = trimmed.startsWith("```") ? stripCodeFence(trimmed) : trimmed;
+  const parsed = JSON.parse(jsonStr);
+  return {
+    contains_data: Boolean(parsed.contains_data),
+    data: parsed.data ?? {}
+  };
+}
+function stripCodeFence(input) {
+  const firstBreak = input.indexOf("\n");
+  if (firstBreak === -1) return input.replace(/```/g, "").trim();
+  const body = input.slice(firstBreak + 1);
+  const lastFence = body.lastIndexOf("```");
+  if (lastFence === -1) return body.trim();
+  return body.slice(0, lastFence).trim();
+}
+
+export {
+  createExtractCallback
+};

package/dist/chunk-L4FHT64T.js

@@ -0,0 +1,109 @@
+// src/ai/model.ts
+var PROVIDER_MAP = {
+  "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" }
+};
+function resolveProviderInfo(modelStr) {
+  for (const [prefix, info] of Object.entries(PROVIDER_MAP)) {
+    if (modelStr.startsWith(prefix)) {
+      return info;
+    }
+  }
+  return { pkg: "@ai-sdk/openai", providerFn: "openai" };
+}
+async function getModelProvider(modelStr) {
+  const { pkg, providerFn } = resolveProviderInfo(modelStr);
+  let mod;
+  try {
+    mod = await import(pkg);
+  } catch {
+    throw new Error(
+      `To use AI resolution with model '${modelStr}', install 'ai' and '${pkg}' with your package manager.`
+    );
+  }
+  const provider = mod[providerFn];
+  if (typeof provider !== "function") {
+    throw new Error(
+      `Provider '${providerFn}' not found in '${pkg}'. Ensure you have the latest version installed.`
+    );
+  }
+  const modelId = modelStr.startsWith("groq/") ? modelStr.slice("groq/".length) : modelStr;
+  return provider(modelId);
+}
+
+// src/ai/prompts.ts
+function buildResolveSystemPrompt() {
+  return `You identify interactive HTML elements in a page snapshot. Each element is annotated with a counter attribute c="N". Your job is to find the element that best matches the user's description for a given action.
+
+Respond with a JSON object:
+- "element": the counter number (integer) of the matching element, or -1 if no match
+- "confidence": a number from 0 to 1 indicating how confident you are
+- "reasoning": a brief explanation of why you chose this element
+
+Only select elements that are interactive and relevant to the action described.`;
+}
+function buildResolveUserPrompt(args) {
+  const parts = [`Action: ${args.action}`, `Description: ${args.description}`];
+  if (args.url) {
+    parts.push(`URL: ${args.url}`);
+  }
+  parts.push("", "Page HTML:", args.html);
+  return parts.join("\n");
+}
+function buildExtractSystemPrompt() {
+  return `You extract structured data from HTML page snapshots. Each element is annotated with a counter attribute c="N".
+
+You will receive a schema describing the fields to extract. For each leaf field in the schema, return a value descriptor that identifies both the source element and, when needed, the specific attribute.
+
+Respond with ONLY a JSON object (no markdown, no explanation):
+- "contains_data": boolean indicating whether the page contains the requested data
+- "data": an object matching the schema structure where each leaf value is one of:
+  - integer counter N -> extract textContent from element c="N"
+  - object { "$c": N, "$a": "attributeName" } -> extract that attribute from element c="N"
+  - string "CURRENT_URL" -> use the current page URL
+  - null -> field not found
+
+Rules:
+- Use integer counters for text extraction
+- Use { "$c": N, "$a": "..." } only when the value must come from an attribute (e.g. href, src, value, content)
+- When a field expects a single image URL and both src and srcset exist, prefer "$a": "src" over "$a": "srcset"
+- Use "CURRENT_URL" only when the field explicitly asks for the current page URL
+- If a field's data is not found on the page, return null
+- For array fields, expand to include ALL matching items on the page
+- Do not infer URL/image/input behavior from field names; encode it explicitly with "$a" when needed`;
+}
+function buildExtractUserPrompt(args) {
+  const parts = [];
+  if (args.description) {
+    parts.push(`Description: ${args.description}`);
+  }
+  if (args.prompt) {
+    parts.push(`Instructions: ${args.prompt}`);
+  }
+  if (args.url) {
+    parts.push(`URL: ${args.url}`);
+  }
+  parts.push(
+    "",
+    "Schema:",
+    JSON.stringify(args.schema, null, 2),
+    "",
+    "Page HTML:",
+    args.html
+  );
+  return parts.join("\n");
+}
+
+export {
+  getModelProvider,
+  buildResolveSystemPrompt,
+  buildResolveUserPrompt,
+  buildExtractSystemPrompt,
+  buildExtractUserPrompt
+};

package/dist/chunk-SRJLH34D.js

@@ -0,0 +1,56 @@
+import {
+  buildResolveSystemPrompt,
+  buildResolveUserPrompt,
+  getModelProvider
+} from "./chunk-L4FHT64T.js";
+
+// src/ai/resolver.ts
+function createResolveCallback(model, options) {
+  const temperature = options?.temperature ?? 1;
+  const maxTokens = options?.maxTokens ?? null;
+  return async (args) => {
+    let generateObject;
+    let z;
+    try {
+      const aiMod = await import("ai");
+      generateObject = aiMod.generateObject;
+    } catch {
+      throw new Error(
+        `To use AI resolution with model '${model}', install 'ai' with your package manager.`
+      );
+    }
+    try {
+      z = await import("zod");
+    } catch {
+      throw new Error(
+        `To use AI resolution with model '${model}', install 'zod' with your package manager.`
+      );
+    }
+    const modelProvider = await getModelProvider(model);
+    const schema = z.object({
+      element: z.number().describe(
+        "Counter number of the matching element, or -1 if no match"
+      ),
+      confidence: z.number().describe("Confidence score from 0 to 1"),
+      reasoning: z.string().describe("Brief explanation of the choice")
+    });
+    const request = {
+      model: modelProvider,
+      schema,
+      system: buildResolveSystemPrompt(),
+      prompt: buildResolveUserPrompt(args),
+      temperature,
+      ...maxTokens == null ? {} : { maxOutputTokens: maxTokens }
+    };
+    const result = await generateObject(request);
+    const { element, confidence } = result.object;
+    if (element < 0 || confidence < 0.1) {
+      return null;
+    }
+    return element;
+  };
+}
+
+export {
+  createResolveCallback
+};