@hatchet-dev/typescript-sdk 1.22.0 → 1.22.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.22.0",
+  "version": "1.22.2",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -50,24 +50,22 @@
     "@bufbuild/protobuf": "^2.11.0",
     "@types/qs": "^6.15.0",
     "abort-controller-x": "^0.5.0",
-    "axios": "^1.13.5",
+    "axios": "^1.15.2",
     "long": "^5.3.1",
     "nice-grpc": "^2.1.14",
     "nice-grpc-common": "^2.0.2",
-    "protobufjs": "^7.4.0",
+    "protobufjs": "^7.5.5",
     "qs": "^6.14.2",
     "semver": "^7.7.4",
-    "yaml": "^2.8.2",
+    "yaml": "^2.8.3",
     "zod-to-json-schema": "^3.24.2"
   },
   "peerDependencies": {
-    "zod": "^3.25.0 || ^4.0.0"
-  },
-  "optionalDependencies": {
+    "zod": "^3.25.0 || ^4.0.0",
     "@anthropic-ai/claude-agent-sdk": "^0.2.87",
     "@grpc/grpc-js": "^1.14.3",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@openai/agents": "0.8.3",
+    "@openai/agents": "0.8.5",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^2.0.0",
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.215.0",
@@ -75,6 +73,41 @@
     "@opentelemetry/sdk-trace-base": "^2.0.0",
     "prom-client": "^15.1.3"
   },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": false
+    },
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    },
+    "@grpc/grpc-js": {
+      "optional": true
+    },
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    },
+    "@openai/agents": {
+      "optional": true
+    },
+    "@opentelemetry/api": {
+      "optional": true
+    },
+    "@opentelemetry/core": {
+      "optional": true
+    },
+    "@opentelemetry/exporter-trace-otlp-grpc": {
+      "optional": true
+    },
+    "@opentelemetry/instrumentation": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-trace-base": {
+      "optional": true
+    },
+    "prom-client": {
+      "optional": true
+    }
+  },
   "scripts": {
     "build": "echo 'build hatchet sdk with `npm run tsc:build` to ensure it is not build during the publish step' && exit 0",
     "postinstall": "node scripts/version-check.js",

package/v1/client/worker/context.d.ts

@@ -412,8 +412,8 @@ export declare class DurableContext<T, K = {}> extends Context<T, K> {
      * @param payloadSchema - An optional Zod schema to validate and parse the event payload.
      * @returns The event payload, validated against the schema if provided.
      */
-    waitForEvent<T extends z.ZodTypeAny>(key: string, expression?: string, payloadSchema?: T, scope?: string, lookbackWindow?: Duration, label?: string): Promise<z.infer<T>>;
     waitForEvent(key: string, expression?: string, payloadSchema?: undefined, scope?: string, lookbackWindow?: Duration, label?: string): Promise<Record<string, any>>;
+    waitForEvent<T extends z.ZodTypeAny>(key: string, expression?: string, payloadSchema?: T, scope?: string, lookbackWindow?: Duration, label?: string): Promise<z.infer<T>>;
     /**
      * Durably sleep until a specific timestamp.
      * Uses the memoized `now()` to compute the remaining duration, then delegates to `sleepFor`.

package/v1/examples/e2e-worker.js

@@ -42,6 +42,7 @@ const workflow_20 = require("./webhooks/workflow");
 const workflow_21 = require("./child_index/workflow");
 const workflow_22 = require("./support_agent/workflow");
 const workflow_23 = require("./welcome_email/workflow");
+const workflow_24 = require("./pdf_pipeline/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -101,6 +102,7 @@ const workflows = [
     workflow_22.generateReply,
     workflow_22.escalateTicket,
     workflow_23.welcomeEmail,
+    workflow_24.pdfPipeline,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/v1/examples/pdf_pipeline/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/pdf_pipeline/run.js

@@ -0,0 +1,31 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// > Trigger the pipeline
+const workflow_1 = require("./workflow");
+const sample_pdf_1 = require("./sample-pdf");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pdfBytes = (0, sample_pdf_1.makeSamplePdf)('Invoice from Acme Corp. Total amount due: 150 dollars. Payment terms: Net 30.');
+        const input = {
+            filename: 'sample-invoice.pdf',
+            contentBase64: pdfBytes.toString('base64'),
+        };
+        const result = yield workflow_1.pdfPipeline.run(input);
+        console.log('Pipeline result:', result);
+    });
+}
+// !!
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/v1/examples/pdf_pipeline/sample-pdf.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Create a minimal single-page PDF containing the given text.
+ * Uses no external dependencies — constructs the PDF binary directly.
+ */
+export declare function makeSamplePdf(text: string): Buffer;

package/v1/examples/pdf_pipeline/sample-pdf.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSamplePdf = makeSamplePdf;
+/**
+ * Create a minimal single-page PDF containing the given text.
+ * Uses no external dependencies — constructs the PDF binary directly.
+ */
+function makeSamplePdf(text) {
+    const stream = `BT /F1 12 Tf 72 720 Td (${text}) Tj ET`;
+    const objects = [
+        '1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj',
+        '2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj',
+        `3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>\nendobj`,
+        `4 0 obj\n<< /Length ${stream.length} >>\nstream\n${stream}\nendstream\nendobj`,
+        '5 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj',
+    ];
+    let body = '%PDF-1.4\n';
+    const offsets = [];
+    for (const obj of objects) {
+        offsets.push(body.length);
+        body += obj + '\n\n';
+    }
+    const xrefOffset = body.length;
+    let xref = `xref\n0 ${objects.length + 1}\n`;
+    xref += '0000000000 65535 f \n';
+    for (const off of offsets) {
+        xref += String(off).padStart(10, '0') + ' 00000 n \n';
+    }
+    body += xref;
+    body += `trailer\n<< /Size ${objects.length + 1} /Root 1 0 R >>\n`;
+    body += `startxref\n${xrefOffset}\n%%EOF`;
+    return Buffer.from(body, 'latin1');
+}

package/v1/examples/pdf_pipeline/workflow.d.ts

@@ -0,0 +1,27 @@
+export type PdfInput = {
+    filename: string;
+    contentBase64: string;
+};
+export type ExtractOutput = {
+    text: string;
+    pageCount: number;
+};
+export type ClassifyOutput = {
+    category: string;
+};
+export type SummaryOutput = {
+    summary: string;
+    wordCount: number;
+};
+export type KeywordsOutput = {
+    keywords: string[];
+};
+export type PipelineResult = {
+    filename: string;
+    category: string;
+    summary: string;
+    keywords: string[];
+    wordCount: number;
+    pageCount: number;
+};
+export declare const pdfPipeline: import("../..").WorkflowDeclaration<PdfInput, {}, {}>;

package/v1/examples/pdf_pipeline/workflow.js

@@ -0,0 +1,179 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pdfPipeline = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const hatchet_client_1 = require("../hatchet-client");
+// !!
+const STOPWORDS = new Set([
+    'a',
+    'an',
+    'and',
+    'are',
+    'as',
+    'at',
+    'be',
+    'by',
+    'for',
+    'from',
+    'in',
+    'is',
+    'it',
+    'of',
+    'on',
+    'or',
+    'that',
+    'the',
+    'to',
+    'with',
+]);
+const MIN_WORD_LENGTH = 3;
+const MAX_KEYWORDS = 6;
+const FALLBACK_TEXT = 'Invoice from Acme Corp. Total amount due: 150 dollars. Payment terms: Net 30.';
+/**
+ * Extract text from a PDF buffer using pdf2json.
+ * The file-path API is the most reliable path for this example.
+ */
+function extractPdfText(pdfBuffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let PDFParser;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            PDFParser = require('pdf2json');
+        }
+        catch (_a) {
+            // pdf2json not installed: return deterministic fallback text
+            return { text: FALLBACK_TEXT, pageCount: 1 };
+        }
+        const tmpDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hatchet-pdf-'));
+        const tmpFile = (0, path_1.join)(tmpDir, 'input.pdf');
+        (0, fs_1.writeFileSync)(tmpFile, pdfBuffer);
+        try {
+            const pdfData = yield new Promise((resolve, reject) => {
+                const parser = new PDFParser();
+                parser.on('pdfParser_dataReady', resolve);
+                parser.on('pdfParser_dataError', (err) => reject(new Error(err.parserError)));
+                parser.loadPDF(tmpFile);
+            });
+            const pageCount = pdfData.Pages.length;
+            const text = pdfData.Pages.map((page) => page.Texts.map((t) => t.R.map((r) => decodeURIComponent(r.T)).join('')).join(' ')).join('\n');
+            return { text, pageCount };
+        }
+        finally {
+            try {
+                (0, fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+            }
+            catch (_b) {
+                // best-effort cleanup
+            }
+        }
+    });
+}
+// > Define the DAG
+exports.pdfPipeline = hatchet_client_1.hatchet.workflow({
+    name: 'pdf-pipeline',
+});
+// !!
+// > Extract text task
+const extractText = exports.pdfPipeline.task({
+    name: 'extract_text',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const decoded = Buffer.from(input.contentBase64, 'base64');
+        const { text, pageCount } = yield extractPdfText(decoded);
+        return { text, pageCount };
+    }),
+});
+// !!
+// > Classify task
+const classifyDocument = exports.pdfPipeline.task({
+    name: 'classify_document',
+    parents: [extractText],
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const { text } = yield ctx.parentOutput(extractText);
+        const lower = text.toLowerCase();
+        let category;
+        if (['invoice', 'amount due', 'payment', 'bill'].some((w) => lower.includes(w))) {
+            category = 'invoice';
+        }
+        else if (['receipt', 'paid', 'transaction'].some((w) => lower.includes(w))) {
+            category = 'receipt';
+        }
+        else if (['report', 'analysis', 'findings', 'conclusion'].some((w) => lower.includes(w))) {
+            category = 'report';
+        }
+        else if (['dear', 'sincerely', 'regards'].some((w) => lower.includes(w))) {
+            category = 'letter';
+        }
+        else {
+            category = 'other';
+        }
+        return { category };
+    }),
+});
+// !!
+// > Summarize task
+const summarizeText = exports.pdfPipeline.task({
+    name: 'summarize_text',
+    parents: [extractText],
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const { text } = yield ctx.parentOutput(extractText);
+        const words = text.split(/\s+/).filter(Boolean);
+        const maxWords = 50;
+        let summary = words.slice(0, maxWords).join(' ');
+        if (words.length > maxWords) {
+            summary += '...';
+        }
+        return { summary, wordCount: words.length };
+    }),
+});
+// !!
+// > Extract keywords task
+const extractKeywords = exports.pdfPipeline.task({
+    name: 'extract_keywords',
+    parents: [extractText],
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const { text } = yield ctx.parentOutput(extractText);
+        const words = (_a = text.toLowerCase().match(/[a-z]+/g)) !== null && _a !== void 0 ? _a : [];
+        const filtered = words.filter((w) => w.length >= MIN_WORD_LENGTH && !STOPWORDS.has(w));
+        const counts = new Map();
+        for (const w of filtered) {
+            counts.set(w, ((_b = counts.get(w)) !== null && _b !== void 0 ? _b : 0) + 1);
+        }
+        const sorted = [...counts.entries()]
+            .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+            .slice(0, MAX_KEYWORDS);
+        return { keywords: sorted.map(([word]) => word) };
+    }),
+});
+// !!
+// > Format result task
+exports.pdfPipeline.task({
+    name: 'format_result',
+    parents: [extractText, classifyDocument, summarizeText, extractKeywords],
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const extract = yield ctx.parentOutput(extractText);
+        const classify = yield ctx.parentOutput(classifyDocument);
+        const summary = yield ctx.parentOutput(summarizeText);
+        const keywords = yield ctx.parentOutput(extractKeywords);
+        return {
+            filename: input.filename,
+            category: classify.category,
+            summary: summary.summary,
+            keywords: keywords.keywords,
+            wordCount: summary.wordCount,
+            pageCount: extract.pageCount,
+        };
+    }),
+});
+// !!

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.22.0";
+export declare const HATCHET_VERSION = "1.22.2";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.22.0';
+exports.HATCHET_VERSION = '1.22.2';