runline 0.18.0 → 0.20.0

package/dist/plugins/shiftOcr/src/index.js

@@ -0,0 +1,153 @@
+import { readFile, stat } from "node:fs/promises";
+import { extname } from "node:path";
+import * as t from "typebox";
+import { request, STRICT_OBJECT } from "../../_shared/shiftCloud.js";
+/**
+ * Shift OCR — text and structured-field extraction from images and
+ * PDFs through the Shift cloud OCR service. The API key is the tenant
+ * authority; no organization ID is ever sent (SHFT-852).
+ */
+const IMAGE_TYPES = {
+    avif: "image/avif",
+    gif: "image/gif",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    png: "image/png",
+    webp: "image/webp",
+};
+const DOCUMENT_TYPES = {
+    pdf: "application/pdf",
+};
+/**
+ * Raw-file ceiling for inlining as a base64 data URL. Base64 inflates
+ * by 4/3, so 20 MiB raw stays well inside provider request limits.
+ */
+const MAX_FILE_BYTES = 20 * 1024 * 1024;
+async function documentFromPath(path) {
+    const extension = extname(path).slice(1).toLowerCase();
+    const imageType = IMAGE_TYPES[extension];
+    const documentType = DOCUMENT_TYPES[extension];
+    if (!imageType && !documentType) {
+        throw new Error(`Unsupported file extension for ${path}. Supported: ${[
+            ...Object.keys(IMAGE_TYPES),
+            ...Object.keys(DOCUMENT_TYPES),
+        ].join(", ")}`);
+    }
+    const file = await stat(path);
+    if (!file.isFile())
+        throw new Error(`${path} is not a file`);
+    if (file.size === 0)
+        throw new Error("File is empty");
+    if (file.size > MAX_FILE_BYTES) {
+        throw new Error(`File is ${file.size} bytes; inline OCR uploads are capped at ${MAX_FILE_BYTES} bytes. Host the file and pass url instead.`);
+    }
+    const mediaType = imageType ?? documentType;
+    const url = `data:${mediaType};base64,${(await readFile(path)).toString("base64")}`;
+    return imageType
+        ? { type: "image", url }
+        : { type: "document", url, name: path.replace(/.*\//, "") };
+}
+function documentFromUrl(url, kind) {
+    if (kind)
+        return { type: kind, url };
+    // Data URLs carry their media type, not an extension.
+    if (url.startsWith("data:")) {
+        return url.startsWith("data:application/pdf")
+            ? { type: "document", url }
+            : { type: "image", url };
+    }
+    const extension = new URL(url).pathname.replace(/.*\./, "").toLowerCase();
+    return DOCUMENT_TYPES[extension]
+        ? { type: "document", url }
+        : { type: "image", url };
+}
+export default function shiftOcr(rl) {
+    rl.setName("shiftOcr");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema(t.Object({
+        // Same Shift Labs API key as the shiftLabs plugin; the cloud
+        // derives the organization from it, so no org ID is needed.
+        apiKey: t.String({
+            description: "Shift Labs API key",
+            env: "SHIFT_LABS_API_KEY",
+        }),
+    }));
+    rl.registerAction("ocr.extract", {
+        access: "write",
+        description: "Extract markdown text — and optionally schema-constrained JSON — " +
+            "from an image or PDF. Pass a local file path (inlined as a data " +
+            "URL) or an https URL. Provide schema to get structured fields " +
+            "back instead of parsing the text yourself.",
+        inputSchema: t.Object({
+            path: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "Host path of an image or PDF (max 20 MiB)",
+            })),
+            url: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "https or data URL of the image or PDF",
+            })),
+            kind: t.Optional(t.Union([t.Literal("image"), t.Literal("document")], {
+                description: "Override for URLs whose extension does not reveal the type. " +
+                    "Inferred from the extension otherwise.",
+            })),
+            pages: t.Optional(t.String({
+                minLength: 1,
+                pattern: "^\\d+(-\\d+)?(,\\d+(-\\d+)?)*$",
+                description: "Zero-based pages for PDFs, e.g. '0', '0-5', or '0,2-4'",
+            })),
+            schema: t.Optional(t.Record(t.String(), t.Unknown(), {
+                description: "JSON schema for structured extraction across the document",
+            })),
+            schemaName: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "Extractor name for provenance. Default: extraction",
+            })),
+            prompt: t.Optional(t.String({
+                minLength: 1,
+                pattern: "\\S",
+                description: "Guidance for structured extraction; requires schema",
+            })),
+        }, STRICT_OBJECT),
+        async execute(input, ctx) {
+            const fields = input;
+            if (!fields.path === !fields.url) {
+                throw new Error("Provide exactly one of path or url");
+            }
+            if (fields.prompt && !fields.schema) {
+                throw new Error("prompt requires schema");
+            }
+            const document = fields.path
+                ? await documentFromPath(fields.path)
+                : documentFromUrl(fields.url, fields.kind);
+            return await request(ctx, "/v1/services/ocr/extract", {
+                method: "POST",
+                body: JSON.stringify({
+                    document,
+                    ...(fields.pages ? { pages: fields.pages } : {}),
+                    ...(fields.schema
+                        ? {
+                            structured: {
+                                name: fields.schemaName ?? "extraction",
+                                schema: fields.schema,
+                                ...(fields.prompt ? { prompt: fields.prompt } : {}),
+                            },
+                        }
+                        : {}),
+                }),
+            });
+        },
+    });
+    rl.registerAction("ocr.providers", {
+        access: "read",
+        description: "List the OCR providers and models available.",
+        inputSchema: t.Object({}, STRICT_OBJECT),
+        async execute(_input, ctx) {
+            const body = await request(ctx, "/v1/services/ocr/providers");
+            return body.providers;
+        },
+    });
+}

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import { type ExecuteResult } from "./core/engine.js";
+import { type ActionInvocation, type ExecuteResult } from "./core/engine.js";
 import type { PluginFunction } from "./plugin/api.js";
 import type { ActionAccess, ConnectionConfig, InputSchema, PluginDef } from "./plugin/types.js";
 export interface RunlineOptions {
@@ -11,6 +11,15 @@ export interface RunlineOptions {
      * `ExecutionEngine` — this bounds cross-run contamination, not memory.
      */
     maxRunsPerWorker?: number;
+    /**
+     * Observer fired in the host process for every action invocation
+     * that enters a plugin's `execute()` — unknown paths and failed
+     * input validation never reach plugin code and are not reported.
+     * Exceptions thrown by the observer are swallowed: observability
+     * never breaks a run. Not part of `RunlineConfig` on purpose —
+     * config round-trips through JSON (`fromProject`), functions do not.
+     */
+    onAction?: (info: ActionInvocation) => void;
 }
 export interface RunlineExecuteOptions {
     timeoutMs?: number;
@@ -25,6 +34,7 @@ export declare class Runline {
      * leak) a fresh worker every time — the exact bug pooling exists to fix.
      */
     private _engine;
+    private readonly _onAction;
     private constructor();
     private engine;
     /**

package/dist/sdk.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { DEFAULT_CONFIG } from "./config/types.js";
-import { ExecutionEngine } from "./core/engine.js";
+import { ExecutionEngine, } from "./core/engine.js";
 import { resolvePluginExport } from "./plugin/api.js";
 import { discoverPlugins } from "./plugin/loader.js";
 import { PluginRegistry } from "./plugin/registry.js";
@@ -14,8 +14,10 @@ export class Runline {
      * leak) a fresh worker every time — the exact bug pooling exists to fix.
      */
     _engine = null;
+    _onAction;
     constructor(options) {
         this._registry = new PluginRegistry();
+        this._onAction = options.onAction;
         for (const pluginOrFn of options.plugins ?? []) {
             const plugin = resolvePluginExport(pluginOrFn, "unknown");
             this._registry.register(plugin);
@@ -31,7 +33,9 @@ export class Runline {
     }
     engine() {
         if (!this._engine) {
-            this._engine = new ExecutionEngine(this._registry, this._config);
+            this._engine = new ExecutionEngine(this._registry, this._config, {
+                onAction: this._onAction,
+            });
         }
         return this._engine;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "runline",
-  "version": "0.18.0",
-  "description": "Code mode for agents — turn any API or command into a callable action",
+  "version": "0.20.0",
+  "description": "Code mode for agents \u2014 turn any API or command into a callable action",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -25,8 +25,7 @@
     "runline": "./dist/main.js"
   },
   "files": [
-    "dist",
-    "vendor"
+    "dist"
   ],
   "scripts": {
     "build": "tsc && bun --filter runline-plugins build && rm -rf dist/plugins && cp -R ../runline-plugins/dist dist/plugins",
@@ -59,7 +58,6 @@
     "@types/bun": "^1.2.17",
     "@types/node": "^25.5.0",
     "@types/proper-lockfile": "^4.1.4",
-    "minisearch": "^7.2.0",
     "typescript": "^5.8.0"
   },
   "peerDependencies": {
@@ -91,6 +89,7 @@
     }
   },
   "dependencies": {
+    "@shift-labs/ferrosearch": "^0.1.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "jiti": "^2.7.0",

package/vendor/README.md

@@ -1,19 +0,0 @@
-# vendor
-
-Third-party bundles inlined into the QuickJS sandbox at runtime.
-
-These files are committed deliberately: the sandbox eval'd source is part of runline's behavior, and PR diffs should show exactly what changes when a bundle is bumped.
-
-## minisearch.umd.js
-
-UMD build of [minisearch](https://github.com/lucaong/minisearch). Read by `src/core/engine.ts` and inlined into the sandbox so `MiniSearch` is available as a global to agent code (powers `actions.find()`).
-
-To upgrade:
-
-```bash
-npm i -D minisearch@latest
-cp node_modules/minisearch/dist/umd/index.js vendor/minisearch.umd.js
-git commit -am "vendor: bump minisearch"
-```
-
-The `minisearch` devDependency exists only as a convenience for that `cp` — nothing imports it at runtime.