@artinet/sdk 0.6.10 → 0.6.12

package/dist/server/express/utils.js

@@ -7,20 +7,16 @@
  */
 import { SystemError } from "../../utils/index.js";
 import { logger } from "../../config/index.js";
-import escapeHtml from "escape-html";
-import { A2AError } from "@a2a-js/sdk/server";
-import { formatJson } from "../../utils/index.js";
-import express from "express";
+import { A2AError } from '@a2a-js/sdk/server';
+import { formatJson, sanitizeString } from "../../utils/index.js";
+import express from 'express';
 export function rpcParser(req, res, next) {
     express.json()(req, res, (err) => {
-        if (!req.body || typeof req.body !== "object") {
+        if (!req.body || typeof req.body !== 'object') {
             return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
         }
         if (err) {
-            if (err instanceof SyntaxError &&
-                "status" in err &&
-                err.status === 400 &&
-                "body" in err) {
+            if (err instanceof SyntaxError && 'status' in err && err.status === 400 && 'body' in err) {
                 return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
             }
             return next(err);
@@ -36,15 +32,15 @@ export const errorHandler = (err, req, res, _) => {
     if (res.headersSent) {
         headersSent = true;
     }
-    logger.error("errorHandler", err);
+    logger.error('errorHandler', err);
     let reqId = null;
     try {
-        if (req.body && typeof req.body === "object" && "id" in req.body) {
+        if (req.body && typeof req.body === 'object' && 'id' in req.body) {
             reqId = req.body.id;
         }
     }
     catch (e) {
-        logger.error("errorHandler: Error extracting request ID", e);
+        logger.error('errorHandler: Error extracting request ID', e);
     }
     let jsonRpcError;
     if (err instanceof A2AError || err instanceof SystemError) {
@@ -54,8 +50,8 @@ export const errorHandler = (err, req, res, _) => {
         jsonRpcError = A2AError.internalError(err.message, err.data).toJSONRPCError();
     }
     const errorResponse = {
-        jsonrpc: "2.0",
-        id: escapeHtml(reqId),
+        jsonrpc: '2.0',
+        id: sanitizeString(reqId),
         error: jsonRpcError,
     };
     if (!headersSent) {

package/dist/services/a2a/factory/state-machine.d.ts

@@ -7,5 +7,5 @@ export declare function createStateMachine({ contextId, service, task: currentTa
     contextId: string;
     service: A2A.Service;
     task: A2A.Task;
-    overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
+    overrides?: Partial<Omit<A2A.EventConsumer, 'contextId'>>;
 }): A2A.EventPublisher;

package/dist/services/a2a/factory/state-machine.js

@@ -7,12 +7,12 @@ import { logger } from "../../../config/index.js";
 import * as describe from "../../../create/describe.js";
 import { TASK_NOT_FOUND } from "../../../utils/errors.js";
 import { formatJson } from "../../../utils/utils.js";
-import assert from "assert";
+// import assert from "assert";
 export function createStateMachine({ contextId, service, task: currentTask, overrides, }) {
     const handler = {
         contextId: contextId,
         onStart: async (context) => {
-            assert(context.contextId === contextId, "context mismatch");
+            // assert(context.contextId === contextId, 'context mismatch');
             logger.info(`onStart[ctx:${contextId}]:`, { taskId: context.taskId });
             await service.connections.set(context.contextId);
             const task = await service.tasks.get(context.taskId);
@@ -24,8 +24,8 @@ export function createStateMachine({ contextId, service, task: currentTask, over
             return task;
         },
         onCancel: async (update, task) => {
-            logger.info(`onCancel[ctx:${contextId}]:`, "cancellation triggered");
-            logger.debug(`onCancel[ctx:${contextId}]:`, "arguments", update, task);
+            logger.info(`onCancel[ctx:${contextId}]:`, 'cancellation triggered');
+            logger.debug(`onCancel[ctx:${contextId}]:`, 'arguments', update, task);
             await service.cancellations.set(task.id);
             const cancellation = describe.update.canceled({
                 taskId: task.id,
@@ -34,13 +34,13 @@ export function createStateMachine({ contextId, service, task: currentTask, over
             });
             /**We've intentionally blocked further updates, so the first cancellation update is responsible for updating stored task state and notifying listeners*/
             const updatedTask = await service.tasks.update((await service.contexts.get(contextId)), cancellation);
-            (await service.contexts.get(contextId))?.publisher.emit("update", updatedTask, cancellation);
+            (await service.contexts.get(contextId))?.publisher.emit('update', updatedTask, cancellation);
         },
         onUpdate: async (update, task) => {
             logger.info(`onUpdate[ctx:${contextId}]:`);
             logger.debug(`onUpdate[ctx:${contextId}]:`, { taskId: task.id });
             if (await service.cancellations.has(task.id)) {
-                logger.warn(`onUpdate[ctx:${contextId}]:`, { taskId: task.id }, "task is cancelled, no longer processing updates");
+                logger.warn(`onUpdate[ctx:${contextId}]:`, { taskId: task.id }, 'task is cancelled, no longer processing updates');
                 return task;
             }
             return await service.tasks.update((await service.contexts.get(contextId)), update);
@@ -48,7 +48,7 @@ export function createStateMachine({ contextId, service, task: currentTask, over
         onError: async (error, task) => {
             logger.error(`onError[ctx:${contextId}]:`, error);
             if (!task) {
-                logger.error(`onError[ctx:${contextId}]:`, new Error("task not found"));
+                logger.error(`onError[ctx:${contextId}]:`, new Error('task not found'));
                 return;
             }
             const errorUpdate = describe.update.failed({
@@ -58,7 +58,7 @@ export function createStateMachine({ contextId, service, task: currentTask, over
                     messageId: `failed:${task.id}`,
                     parts: [
                         {
-                            kind: "text",
+                            kind: 'text',
                             text: error instanceof Error ? error.message : formatJson(error),
                         },
                     ],
@@ -66,7 +66,7 @@ export function createStateMachine({ contextId, service, task: currentTask, over
             });
             const context = await service.contexts.get(contextId);
             if (!context) {
-                logger.error(`onError[ctx:${contextId}]:`, new Error("context not found"));
+                logger.error(`onError[ctx:${contextId}]:`, new Error('context not found'));
                 return;
             }
             /**triggering onUpdate here with a catch instead of a raw tasks.update call*/
@@ -77,7 +77,7 @@ export function createStateMachine({ contextId, service, task: currentTask, over
             await context.publisher.onComplete();
         },
         onComplete: async (task) => {
-            assert(task.contextId === contextId, "context mismatch");
+            // assert(task.contextId === contextId, 'context mismatch');
             logger.info(`onComplete[ctx:${contextId}]: `, { taskId: task.id });
             await service.cancellations.delete(task.id);
             await service.connections.delete(task.contextId);

package/dist/services/a2a/managers.d.ts

@@ -17,7 +17,7 @@ export declare class Streams extends Manager<A2A.Stream> implements A2A.Streams
     }): Promise<A2A.Stream>;
 }
 export declare class Tasks extends Manager<A2A.Task> implements A2A.Tasks {
-    constructor(tasks?: Map<string, A2A.Task>);
+    constructor(tasks?: Map<string, A2A.Task>, storage?: core.Manager<A2A.Task>);
     update(context: A2A.Context, update: A2A.Update): Promise<A2A.Task>;
     create(params: Partial<A2A.Task>): Promise<A2A.Task>;
 }

package/dist/services/a2a/managers.js

@@ -1,7 +1,7 @@
 import { A2A } from "../../types/index.js";
-import { Stream } from "./streams.js";
-import { createBaseContext, createContext, } from "./factory/context.js";
-import { v4 } from "uuid";
+import { Stream } from './streams.js';
+import { createBaseContext, createContext } from "./factory/context.js";
+import { v4 } from 'uuid';
 import { getCurrentTimestamp } from "../../utils/index.js";
 import { handleUpdate } from "./handlers/update.js";
 import { Manager } from "../core/manager.js";
@@ -22,7 +22,7 @@ export class Contexts extends Manager {
     }
     async create(params) {
         if (await this.has(params.contextId)) {
-            logger.warn("Contexts[create]: context already exists", {
+            logger.warn('Contexts[create]: context already exists', {
                 contextId: params.contextId,
             });
             return (await this.get(params.contextId));
@@ -54,26 +54,30 @@ export class Streams extends Manager {
     }
     async create({ contextId, context, updates, }) {
         if (await this.has(contextId)) {
-            throw new Error("Stream already exists");
+            throw new Error('Stream already exists');
         }
         await this.set(contextId, new Stream(contextId, context, updates));
         return (await this.get(contextId));
     }
 }
 export class Tasks extends Manager {
-    constructor(tasks = new Map()) {
-        super(tasks, true);
+    constructor(tasks = new Map(), storage) {
+        super(tasks, true, storage);
     }
     async update(context, update) {
         logger.info(`Tasks[update]: updating task`, { taskId: context.taskId });
         logger.debug(`Tasks[update]: update`, { update });
         logger.debug(`Tasks[update]: context`, { context });
+        const currentTask = await context.getTask();
+        if (!currentTask) {
+            throw new Error(`Task not found: ${context.taskId}`);
+        }
         logger.debug(`Tasks[update]: context task`, {
-            task: await context.getTask(),
+            task: currentTask,
         });
         const task = await handleUpdate({
             context,
-            task: await context.getTask(),
+            task: currentTask,
             update,
         });
         logger.debug(`Tasks[update]: task`, task);
@@ -81,15 +85,18 @@ export class Tasks extends Manager {
         return task;
     }
     async create(params) {
-        if (params.id && (await this.has(params.id))) {
-            return (await this.get(params.id));
+        if (params.id) {
+            const task = await this.get(params.id);
+            if (task) {
+                return task;
+            }
         }
         logger.info(`Tasks[create]: creating task`, { id: params.id });
         const task = {
             ...params,
             id: params.id ?? v4(),
             contextId: params.contextId ?? v4(),
-            kind: "task",
+            kind: 'task',
             status: {
                 state: A2A.TaskState.submitted,
                 timestamp: getCurrentTimestamp(),

package/dist/services/core/manager.js

@@ -88,14 +88,11 @@ export class Manager {
         }
         const results = [];
         if (filter) {
-            const items = Array.from(this.cache.values());
-            const filterResults = await Promise.all(items.map(async (item) => {
+            for (const item of this.cache.values()) {
                 if (await filter(item)) {
-                    return item;
+                    results.push(item);
                 }
-                return undefined;
-            }));
-            results.push(...filterResults.filter((item) => item !== undefined));
+            }
         }
         if (this.storage) {
             const storageFilter = async (item) => {

package/dist/storage/file.js

@@ -3,8 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../types/index.js";
-import fs from "fs/promises";
-import path from "path";
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import { logger } from "../config/index.js";
 import { Tasks } from "../services/a2a/managers.js";
 import { formatJson, safeParseSchema } from "../utils/index.js";
@@ -19,6 +19,7 @@ export class Files extends Tasks {
      * @param baseDir The base directory to store task files in.
      */
     constructor(baseDir) {
+        //TODO: we're inverting the dependency injection pattern here. Tasks should take the storage instance
         super(new Map());
         this.baseDir = baseDir;
         logger.info(`FileStore[init]: baseDir`, { baseDir });
@@ -54,7 +55,7 @@ export class Files extends Tasks {
         try {
             await this.ensureBaseDir();
             await fs.writeFile(filePath, formatJson(task), {
-                encoding: "utf8",
+                encoding: 'utf8',
             });
         }
         catch (error) {
@@ -69,11 +70,11 @@ export class Files extends Tasks {
      */
     async readJsonFile(filePath) {
         try {
-            const content = await fs.readFile(filePath, { encoding: "utf8" });
+            const content = await fs.readFile(filePath, { encoding: 'utf8' });
             return await safeParseSchema(content, A2A.TaskSchema);
         }
         catch (error) {
-            if (error.code === "ENOENT") {
+            if (error.code === 'ENOENT') {
                 logger.warn(`FileStore[readJsonFile]: ${filePath} not found`);
                 return null;
             }
@@ -86,8 +87,7 @@ export class Files extends Tasks {
      * @returns A promise resolving to the task and history, or null if not found.
      */
     async get(taskId) {
-        const task = (await super.get(taskId)) ??
-            (await this.readJsonFile(this.getTaskFilePath(taskId)).catch(() => undefined));
+        const task = (await super.get(taskId)) ?? (await this.readJsonFile(this.getTaskFilePath(taskId)).catch(() => undefined));
         return task ?? undefined;
     }
     /**
@@ -101,8 +101,8 @@ export class Files extends Tasks {
             return;
         }
         if (task && taskId !== task.id) {
-            logger.warn("FileStore", `Task ID mismatch: ${taskId} !== ${task.id}`);
-            throw new Error("Task ID mismatch");
+            logger.warn('FileStore', `Task ID mismatch: ${taskId} !== ${task.id}`);
+            throw new Error('Task ID mismatch');
         }
         const taskFilePath = this.getTaskFilePath(taskId);
         await this.writeJsonFile(taskFilePath, task);

package/dist/storage/sqlite.d.ts

@@ -6,7 +6,7 @@ import { A2A } from "../types/index.js";
 import { Tasks } from "../services/a2a/managers.js";
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 export declare const TABLE_NAME = "artinet_tasks";
-export declare const createTaskTable: (db: BaseSQLiteDatabase<`sync` | `async`, any, TaskTable>) => Promise<void>;
+export declare const createTaskTable: (db: BaseSQLiteDatabase<`sync` | `async`, any, TaskTable>, tableName?: string) => Promise<void>;
 export declare const TaskTable: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "artinet_tasks";
     schema: undefined;
@@ -345,7 +345,7 @@ export declare const TaskTable: import("drizzle-orm/sqlite-core").SQLiteTableWit
 export type TaskTable = typeof TaskTable.$inferSelect;
 export declare class SQLiteStore extends Tasks {
     private db;
-    constructor(db: BaseSQLiteDatabase<`sync` | `async`, any, TaskTable>, tasks?: Map<string, A2A.Task>);
+    constructor(db: BaseSQLiteDatabase<`sync` | `async`, any, TaskTable>, tasks?: Map<string, A2A.Task>, tableName?: string);
     has(id: string): Promise<boolean>;
     list(): Promise<A2A.Task[]>;
     get(id: string): Promise<A2A.Task | undefined>;

package/dist/storage/sqlite.js

@@ -7,14 +7,14 @@ import { eq, like, or /*Table, TableConfig*/ } from 'drizzle-orm';
 import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
 import { logger } from "../config/index.js";
 export const TABLE_NAME = 'artinet_tasks';
-const CREATE_TASKS_TABLE_SQL = `CREATE TABLE IF NOT EXISTS ${TABLE_NAME}\
+const CREATE_TASKS_TABLE_SQL = (tableName = TABLE_NAME) => `CREATE TABLE IF NOT EXISTS ${tableName}\
  (id TEXT PRIMARY KEY, contextId TEXT NOT NULL,\
   kind TEXT NOT NULL, status TEXT NOT NULL,\
   history TEXT NOT NULL,\
   artifacts TEXT NOT NULL,\
   metadata TEXT NOT NULL)`;
-export const createTaskTable = async (db) => {
-    await db.run(CREATE_TASKS_TABLE_SQL);
+export const createTaskTable = async (db, tableName = TABLE_NAME) => {
+    await db.run(CREATE_TASKS_TABLE_SQL(tableName));
 };
 /*export type TTable = Table<TableConfig>; //TODO: Unwind Config/Column types */
 export const TaskTable = sqliteTable(TABLE_NAME, {
@@ -28,10 +28,12 @@ export const TaskTable = sqliteTable(TABLE_NAME, {
 });
 export class SQLiteStore extends Tasks {
     db;
-    constructor(db, tasks = new Map()) {
+    //TODO: better for this to be a factory function? We're forcing the table/table name onto the user.
+    constructor(db, tasks = new Map(), tableName = TABLE_NAME) {
+        //TODO: we're inverting the dependency injection pattern here. Tasks should take the storage instance
         super(tasks);
         this.db = db;
-        createTaskTable(db);
+        createTaskTable(db, tableName);
     }
     async has(id) {
         return ((await super.has(id)) ||

package/dist/utils/utils.d.ts

@@ -1,7 +1,9 @@
 /**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
+ * Sanitizes a string by escaping HTML characters to prevent XSS attacks.
+ * @param str - The string to sanitize.
+ * @returns The sanitized string.
  */
+export declare function sanitizeString(str: string): string;
 /**
  * Generates a timestamp in ISO 8601 format.
  * @returns The current timestamp as a string.

package/dist/utils/utils.js

@@ -2,6 +2,16 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
+import escapeHtml from 'escape-html';
+import { Buffer } from 'node:buffer';
+/**
+ * Sanitizes a string by escaping HTML characters to prevent XSS attacks.
+ * @param str - The string to sanitize.
+ * @returns The sanitized string.
+ */
+export function sanitizeString(str) {
+    return escapeHtml(str).trim();
+}
 /**
  * Generates a timestamp in ISO 8601 format.
  * @returns The current timestamp as a string.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@artinet/sdk",
-    "version": "0.6.10",
+    "version": "0.6.12",
     "description": "A TypeScript SDK for building collaborative AI agents.",
     "type": "module",
     "main": "./dist/index.js",
@@ -38,9 +38,9 @@
             "default": "./dist/storage/sqlite.js"
         },
         "./express": {
-            "types": "./dist/server/express/server.d.ts",
-            "import": "./dist/server/express/server.js",
-            "default": "./dist/server/express/server.js"
+            "types": "./dist/server/express/module.d.ts",
+            "import": "./dist/server/express/module.js",
+            "default": "./dist/server/express/module.js"
         },
         "./trpc": {
             "types": "./dist/transport/trpc/index.d.ts",
@@ -152,6 +152,9 @@
         },
         "drizzle-orm": {
             "optional": true
+        },
+        "serverless-http": {
+            "optional": true
         }
     },
     "devDependencies": {