@ap3x/a2a 1.0.0 → 2.0.0

package/dist/grpc-5DAU6EYQ.js

@@ -0,0 +1,591 @@
+import {
+  A2A_ERROR_CODES,
+  A2aClientError,
+  IllegalTaskTransitionError,
+  MessageSchema,
+  TaskNotFoundError,
+  constantTimeEqual,
+  isTerminal
+} from "./chunk-PYM7LV6R.js";
+
+// src/bindings/grpc.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import * as grpc from "@grpc/grpc-js";
+import * as protoLoader from "@grpc/proto-loader";
+import { Value } from "@sinclair/typebox/value";
+var A2aGrpcMappingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "A2aGrpcMappingError";
+  }
+};
+var TASK_STATE_TO_PROTO = {
+  submitted: "TASK_STATE_SUBMITTED",
+  working: "TASK_STATE_WORKING",
+  input_required: "TASK_STATE_INPUT_REQUIRED",
+  auth_required: "TASK_STATE_AUTH_REQUIRED",
+  completed: "TASK_STATE_COMPLETED",
+  failed: "TASK_STATE_FAILED",
+  canceled: "TASK_STATE_CANCELED",
+  rejected: "TASK_STATE_REJECTED"
+};
+var TASK_STATE_FROM_PROTO = new Map(
+  Object.entries(TASK_STATE_TO_PROTO).map(([state, proto]) => [
+    proto,
+    state
+  ])
+);
+function taskStateToProto(state) {
+  const proto = TASK_STATE_TO_PROTO[state];
+  if (proto === void 0) throw new A2aGrpcMappingError(`unmappable A2A task state: ${state}`);
+  return proto;
+}
+function taskStateFromProto(value) {
+  const state = typeof value === "string" ? TASK_STATE_FROM_PROTO.get(value) : void 0;
+  if (state === void 0) {
+    throw new A2aGrpcMappingError(`unmappable proto TaskState: ${String(value)}`);
+  }
+  return state;
+}
+function toProtoValue(value) {
+  if (value === null || value === void 0) return { nullValue: "NULL_VALUE" };
+  if (typeof value === "number") return { numberValue: value };
+  if (typeof value === "string") return { stringValue: value };
+  if (typeof value === "boolean") return { boolValue: value };
+  if (Array.isArray(value)) return { listValue: { values: value.map(toProtoValue) } };
+  return { structValue: toProtoStruct(value) };
+}
+function toProtoStruct(record) {
+  const fields = {};
+  for (const [key, value] of Object.entries(record)) fields[key] = toProtoValue(value);
+  return { fields };
+}
+function fromProtoValue(value) {
+  switch (value.kind) {
+    case "numberValue":
+      return value.numberValue ?? 0;
+    case "stringValue":
+      return value.stringValue ?? "";
+    case "boolValue":
+      return value.boolValue ?? false;
+    case "structValue":
+      return fromProtoStruct(value.structValue ?? {});
+    case "listValue":
+      return (value.listValue?.values ?? []).map(fromProtoValue);
+    default:
+      return null;
+  }
+}
+function fromProtoStruct(struct) {
+  const out = {};
+  for (const [key, value] of Object.entries(struct.fields ?? {})) out[key] = fromProtoValue(value);
+  return out;
+}
+function toProtoTimestamp(iso) {
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms)) throw new A2aGrpcMappingError(`unparsable A2A timestamp: ${iso}`);
+  return { seconds: Math.floor(ms / 1e3), nanos: ms % 1e3 * 1e6 };
+}
+function fromProtoTimestamp(ts) {
+  return new Date((ts.seconds ?? 0) * 1e3 + Math.round((ts.nanos ?? 0) / 1e6)).toISOString();
+}
+function partToProto(part) {
+  const extras = {
+    ...part.mediaType !== void 0 ? { mediaType: part.mediaType } : {},
+    ...part.metadata !== void 0 ? { metadata: toProtoStruct(part.metadata) } : {}
+  };
+  switch (part.kind) {
+    case "text":
+      return { text: part.text, ...extras };
+    case "url":
+      return { url: part.url, ...extras };
+    case "raw":
+      return { raw: part.data, ...extras };
+    case "data":
+      return { data: toProtoValue(part.data), ...extras };
+  }
+}
+function partFromProto(proto) {
+  const extras = {
+    ...proto.mediaType !== void 0 && proto.mediaType !== "" ? { mediaType: proto.mediaType } : {},
+    ...proto.metadata !== void 0 ? { metadata: fromProtoStruct(proto.metadata) } : {}
+  };
+  switch (proto.content) {
+    case "text":
+      return { kind: "text", text: proto.text ?? "", ...extras };
+    case "url":
+      return { kind: "url", url: proto.url ?? "", ...extras };
+    case "raw":
+      return { kind: "raw", data: proto.raw ?? "", ...extras };
+    case "data": {
+      const value = fromProtoValue(proto.data ?? {});
+      if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new A2aGrpcMappingError("proto data Part is not a JSON object");
+      }
+      return { kind: "data", data: value, ...extras };
+    }
+    default:
+      throw new A2aGrpcMappingError("proto Part carries no content");
+  }
+}
+function roleFromProto(value) {
+  if (value === "ROLE_USER") return "user";
+  if (value === "ROLE_AGENT") return "agent";
+  throw new A2aGrpcMappingError(`unmappable proto Role: ${String(value)}`);
+}
+function messageToProto(message) {
+  return {
+    messageId: message.messageId,
+    ...message.contextId !== void 0 ? { contextId: message.contextId } : {},
+    ...message.taskId !== void 0 ? { taskId: message.taskId } : {},
+    role: message.role === "user" ? "ROLE_USER" : "ROLE_AGENT",
+    parts: message.parts.map(partToProto),
+    ...message.metadata !== void 0 ? { metadata: toProtoStruct(message.metadata) } : {}
+  };
+}
+function messageFromProto(proto) {
+  return {
+    messageId: proto.messageId ?? "",
+    // proto3 empty string means unset for the optional ids.
+    ...proto.contextId ? { contextId: proto.contextId } : {},
+    ...proto.taskId ? { taskId: proto.taskId } : {},
+    role: roleFromProto(proto.role),
+    parts: (proto.parts ?? []).map(partFromProto),
+    ...proto.metadata !== void 0 ? { metadata: fromProtoStruct(proto.metadata) } : {}
+  };
+}
+function statusToProto(status2) {
+  return {
+    state: taskStateToProto(status2.state),
+    ...status2.message !== void 0 ? { message: messageToProto(status2.message) } : {},
+    ...status2.timestamp !== void 0 ? { timestamp: toProtoTimestamp(status2.timestamp) } : {}
+  };
+}
+function statusFromProto(proto) {
+  return {
+    state: taskStateFromProto(proto.state),
+    ...proto.message !== void 0 ? { message: messageFromProto(proto.message) } : {},
+    ...proto.timestamp !== void 0 ? { timestamp: fromProtoTimestamp(proto.timestamp) } : {}
+  };
+}
+function artifactToProto(artifact) {
+  return {
+    artifactId: artifact.artifactId,
+    ...artifact.name !== void 0 ? { name: artifact.name } : {},
+    ...artifact.description !== void 0 ? { description: artifact.description } : {},
+    parts: artifact.parts.map(partToProto),
+    ...artifact.metadata !== void 0 ? { metadata: toProtoStruct(artifact.metadata) } : {}
+  };
+}
+function artifactFromProto(proto) {
+  return {
+    artifactId: proto.artifactId ?? "",
+    ...proto.name ? { name: proto.name } : {},
+    ...proto.description ? { description: proto.description } : {},
+    parts: (proto.parts ?? []).map(partFromProto),
+    ...proto.metadata !== void 0 ? { metadata: fromProtoStruct(proto.metadata) } : {}
+  };
+}
+function taskToProto(task) {
+  return {
+    id: task.id,
+    contextId: task.contextId,
+    status: statusToProto(task.status),
+    ...task.artifacts !== void 0 ? { artifacts: task.artifacts.map(artifactToProto) } : {},
+    ...task.history !== void 0 ? { history: task.history.map(messageToProto) } : {}
+  };
+}
+function taskFromProto(proto) {
+  if (proto.status === void 0) throw new A2aGrpcMappingError("proto Task is missing status");
+  return {
+    id: proto.id ?? "",
+    contextId: proto.contextId ?? "",
+    status: statusFromProto(proto.status),
+    ...proto.artifacts !== void 0 && proto.artifacts.length > 0 ? { artifacts: proto.artifacts.map(artifactFromProto) } : {},
+    ...proto.history !== void 0 && proto.history.length > 0 ? { history: proto.history.map(messageFromProto) } : {}
+  };
+}
+function statusUpdateToProto(event) {
+  return {
+    taskId: event.taskId,
+    contextId: event.contextId,
+    status: statusToProto(event.status),
+    ...event.metadata !== void 0 ? { metadata: toProtoStruct(event.metadata) } : {}
+  };
+}
+function statusUpdateFromProto(proto) {
+  const status2 = statusFromProto(proto.status ?? {});
+  return {
+    kind: "status-update",
+    taskId: proto.taskId ?? "",
+    contextId: proto.contextId ?? "",
+    status: status2,
+    final: isTerminal(status2.state),
+    ...proto.metadata !== void 0 ? { metadata: fromProtoStruct(proto.metadata) } : {}
+  };
+}
+function artifactUpdateFromProto(proto) {
+  if (proto.artifact === void 0) {
+    throw new A2aGrpcMappingError("proto artifact update is missing artifact");
+  }
+  return {
+    kind: "artifact-update",
+    taskId: proto.taskId ?? "",
+    contextId: proto.contextId ?? "",
+    artifact: artifactFromProto(proto.artifact),
+    ...proto.append !== void 0 ? { append: proto.append } : {},
+    ...proto.lastChunk !== void 0 ? { lastChunk: proto.lastChunk } : {},
+    ...proto.metadata !== void 0 ? { metadata: fromProtoStruct(proto.metadata) } : {}
+  };
+}
+function protoDir() {
+  for (const relative of ["../../proto/", "../proto/"]) {
+    const dir = fileURLToPath(new URL(relative, import.meta.url));
+    if (existsSync(join(dir, "a2a.proto"))) return dir;
+  }
+  throw new Error("a2a.proto not found relative to the @ap3x/a2a module");
+}
+var serviceCtor;
+function loadServiceCtor() {
+  if (serviceCtor === void 0) {
+    const dir = protoDir();
+    const definition = protoLoader.loadSync(join(dir, "a2a.proto"), {
+      keepCase: false,
+      // snake_case wire fields -> camelCase JS, matching the model
+      longs: Number,
+      enums: String,
+      bytes: String,
+      // proto bytes <-> base64 strings, matching RawPart
+      defaults: false,
+      oneofs: true,
+      includeDirs: [dir]
+    });
+    const pkg = grpc.loadPackageDefinition(definition);
+    serviceCtor = pkg.lf.a2a.v1.A2AService;
+  }
+  return serviceCtor;
+}
+function serviceError(code, message) {
+  return Object.assign(new Error(message), {
+    code,
+    details: message,
+    metadata: new grpc.Metadata()
+  });
+}
+function mapThrown(error) {
+  if (error instanceof TaskNotFoundError) return serviceError(grpc.status.NOT_FOUND, error.message);
+  if (error instanceof IllegalTaskTransitionError) {
+    return serviceError(grpc.status.FAILED_PRECONDITION, error.message);
+  }
+  if (error instanceof A2aGrpcMappingError) {
+    return serviceError(grpc.status.INVALID_ARGUMENT, error.message);
+  }
+  return serviceError(grpc.status.INTERNAL, error instanceof Error ? error.message : String(error));
+}
+function inboundMessage(proto) {
+  if (proto === void 0) throw new A2aGrpcMappingError("request is missing message");
+  const message = messageFromProto(proto);
+  if (!Value.Check(MessageSchema, message)) {
+    throw new A2aGrpcMappingError("invalid A2A message");
+  }
+  return message;
+}
+function writeFrame(call, frame) {
+  if (!call.cancelled && call.writable) call.write(frame);
+}
+function endStream(call) {
+  if (!call.cancelled && call.writable) call.end();
+}
+async function startGrpcServer(executor, options) {
+  const ctor = loadServiceCtor();
+  const server = new grpc.Server();
+  const authError = (metadata) => {
+    if (options.bearerToken === void 0) return void 0;
+    const denied = serviceError(grpc.status.UNAUTHENTICATED, "missing or invalid bearer token");
+    const header = metadata.get("authorization")[0];
+    if (typeof header !== "string" || !header.startsWith("Bearer ")) return denied;
+    if (!constantTimeEqual(header.slice("Bearer ".length), options.bearerToken)) return denied;
+    return void 0;
+  };
+  const unimplemented = (_call, callback) => {
+    callback(serviceError(grpc.status.UNIMPLEMENTED, "not supported by this A2A v1 server"), null);
+  };
+  const handlers = {
+    SendMessage: ((call, callback) => {
+      const denied = authError(call.metadata);
+      if (denied) return callback(denied, null);
+      void (async () => {
+        try {
+          const message = inboundMessage(call.request?.message);
+          const task = await executor.sendMessage(message, {
+            blocking: !(call.request?.configuration?.returnImmediately ?? false)
+          });
+          callback(null, { task: taskToProto(task) });
+        } catch (error) {
+          callback(mapThrown(error), null);
+        }
+      })();
+    }),
+    SendStreamingMessage: ((call) => {
+      const denied = authError(call.metadata);
+      if (denied) {
+        call.emit("error", denied);
+        return;
+      }
+      let message;
+      try {
+        message = inboundMessage(call.request?.message);
+      } catch (error) {
+        call.emit("error", mapThrown(error));
+        return;
+      }
+      executor.sendMessage(message, {
+        blocking: false,
+        // Spec: the stream MUST begin with the full Task object.
+        onTask: (task) => writeFrame(call, { task: taskToProto(task) }),
+        onEvent: (event) => {
+          writeFrame(call, { statusUpdate: statusUpdateToProto(event) });
+          if (event.final) endStream(call);
+        }
+      }).catch((error) => call.emit("error", mapThrown(error)));
+    }),
+    GetTask: ((call, callback) => {
+      const denied = authError(call.metadata);
+      if (denied) return callback(denied, null);
+      const id = call.request?.id ?? "";
+      const task = executor.getTask(id);
+      if (!task)
+        return callback(serviceError(grpc.status.NOT_FOUND, `A2A task not found: ${id}`), null);
+      callback(null, taskToProto(task));
+    }),
+    ListTasks: ((call, callback) => {
+      const denied = authError(call.metadata);
+      if (denied) return callback(denied, null);
+      try {
+        const filter = {
+          ...call.request?.contextId ? { contextId: call.request.contextId } : {},
+          ...call.request?.status !== void 0 ? { state: taskStateFromProto(call.request.status) } : {}
+        };
+        const tasks = executor.listTasks(filter).map(taskToProto);
+        callback(null, {
+          tasks,
+          nextPageToken: "",
+          pageSize: tasks.length,
+          totalSize: tasks.length
+        });
+      } catch (error) {
+        callback(mapThrown(error), null);
+      }
+    }),
+    CancelTask: ((call, callback) => {
+      const denied = authError(call.metadata);
+      if (denied) return callback(denied, null);
+      try {
+        callback(null, taskToProto(executor.cancel(call.request?.id ?? "")));
+      } catch (error) {
+        callback(mapThrown(error), null);
+      }
+    }),
+    SubscribeToTask: ((call) => {
+      const denied = authError(call.metadata);
+      if (denied) {
+        call.emit("error", denied);
+        return;
+      }
+      const id = call.request?.id ?? "";
+      const task = executor.getTask(id);
+      if (!task) {
+        call.emit("error", serviceError(grpc.status.NOT_FOUND, `A2A task not found: ${id}`));
+        return;
+      }
+      writeFrame(call, { task: taskToProto(task) });
+      if (isTerminal(task.status.state)) {
+        writeFrame(call, {
+          statusUpdate: statusUpdateToProto({
+            kind: "status-update",
+            taskId: task.id,
+            contextId: task.contextId,
+            status: task.status,
+            final: true
+          })
+        });
+        endStream(call);
+        return;
+      }
+      const unsubscribe = executor.subscribe(task.id, (event) => {
+        writeFrame(call, { statusUpdate: statusUpdateToProto(event) });
+        if (event.final) endStream(call);
+      });
+      call.on("cancelled", unsubscribe);
+    }),
+    // Out of v1 scope — spec-legal UNIMPLEMENTED.
+    CreateTaskPushNotificationConfig: unimplemented,
+    GetTaskPushNotificationConfig: unimplemented,
+    ListTaskPushNotificationConfigs: unimplemented,
+    DeleteTaskPushNotificationConfig: unimplemented,
+    GetExtendedAgentCard: unimplemented
+  };
+  server.addService(ctor.service, handlers);
+  const bindHost = options.host.includes(":") ? `[${options.host}]` : options.host;
+  const port = await new Promise((resolve, reject) => {
+    server.bindAsync(
+      `${bindHost}:${options.port}`,
+      grpc.ServerCredentials.createInsecure(),
+      (error, boundPort) => error ? reject(error) : resolve(boundPort)
+    );
+  });
+  return {
+    url: `${bindHost}:${port}`,
+    // forceShutdown: close() must never hang on open subscription streams.
+    close: async () => {
+      server.forceShutdown();
+    }
+  };
+}
+function a2aCodeFor(code) {
+  switch (code) {
+    case grpc.status.NOT_FOUND:
+      return A2A_ERROR_CODES.taskNotFound;
+    case grpc.status.FAILED_PRECONDITION:
+      return A2A_ERROR_CODES.taskNotCancelable;
+    case grpc.status.INVALID_ARGUMENT:
+      return A2A_ERROR_CODES.invalidParams;
+    case grpc.status.UNIMPLEMENTED:
+      return A2A_ERROR_CODES.unsupportedOperation;
+    default:
+      return void 0;
+  }
+}
+function normalizeGrpcTarget(url) {
+  return url.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/\/+$/, "");
+}
+var GrpcClientTransport = class {
+  client;
+  timeoutMs;
+  bearerToken;
+  constructor(target, options) {
+    const ctor = loadServiceCtor();
+    this.client = new ctor(normalizeGrpcTarget(target), grpc.credentials.createInsecure());
+    this.timeoutMs = options.timeoutMs;
+    if (options.bearerToken !== void 0) this.bearerToken = options.bearerToken;
+  }
+  /** Close the underlying channel (keeps the event loop free after tests). */
+  close() {
+    this.client.close();
+  }
+  async sendMessage(message, config) {
+    const request = {
+      message: messageToProto(message),
+      ...config !== void 0 ? { configuration: { returnImmediately: config.returnImmediately ?? false } } : {}
+    };
+    const response = await this.unary("SendMessage", request);
+    if (response?.task !== void 0) {
+      return this.convert(() => taskFromProto(response.task), "SendMessage");
+    }
+    if (response?.message !== void 0) {
+      return this.convert(() => messageFromProto(response.message), "SendMessage");
+    }
+    throw new A2aClientError("A2A SendMessage returned no task or message payload");
+  }
+  sendStreamingMessage(message) {
+    return this.stream("SendStreamingMessage", { message: messageToProto(message) });
+  }
+  async getTask(id) {
+    const response = await this.unary("GetTask", { id });
+    return this.convert(() => taskFromProto(response), "GetTask");
+  }
+  async listTasks(filter = {}) {
+    const request = {
+      ...filter.contextId !== void 0 ? { contextId: filter.contextId } : {},
+      ...filter.state !== void 0 ? { status: taskStateToProto(filter.state) } : {}
+    };
+    const response = await this.unary("ListTasks", request);
+    return this.convert(() => (response.tasks ?? []).map(taskFromProto), "ListTasks");
+  }
+  async cancelTask(id) {
+    const response = await this.unary("CancelTask", { id });
+    return this.convert(() => taskFromProto(response), "CancelTask");
+  }
+  subscribeToTask(id) {
+    return this.stream("SubscribeToTask", { id });
+  }
+  metadata() {
+    const metadata = new grpc.Metadata();
+    if (this.bearerToken !== void 0) {
+      metadata.set("authorization", `Bearer ${this.bearerToken}`);
+    }
+    return metadata;
+  }
+  callOptions() {
+    return { deadline: new Date(Date.now() + this.timeoutMs) };
+  }
+  wrapError(error, op) {
+    if (error instanceof A2aClientError) return error;
+    const message = error instanceof Error ? error.message : String(error);
+    const code = a2aCodeFor(error.code);
+    return new A2aClientError(`A2A ${op} failed: ${message}`, code);
+  }
+  convert(fn, op) {
+    try {
+      return fn();
+    } catch (error) {
+      throw new A2aClientError(
+        `A2A ${op} returned a malformed result: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  unary(method, request) {
+    return new Promise((resolve, reject) => {
+      const call = this.client[method];
+      if (call === void 0) {
+        reject(new A2aClientError(`A2A ${method} is not a known gRPC method`));
+        return;
+      }
+      call.call(
+        this.client,
+        request,
+        this.metadata(),
+        this.callOptions(),
+        (error, response) => error ? reject(this.wrapError(error, method)) : resolve(response)
+      );
+    });
+  }
+  async *stream(method, request) {
+    const call = this.client[method];
+    if (call === void 0) throw new A2aClientError(`A2A ${method} is not a known gRPC method`);
+    const stream = call.call(this.client, request, this.metadata(), this.callOptions());
+    try {
+      for await (const chunk of stream) {
+        if (chunk.payload === "task" && chunk.task !== void 0) {
+          yield this.convert(() => taskFromProto(chunk.task), method);
+        } else if (chunk.payload === "statusUpdate" && chunk.statusUpdate !== void 0) {
+          yield this.convert(
+            () => statusUpdateFromProto(chunk.statusUpdate),
+            method
+          );
+        } else if (chunk.payload === "artifactUpdate" && chunk.artifactUpdate !== void 0) {
+          yield this.convert(
+            () => artifactUpdateFromProto(chunk.artifactUpdate),
+            method
+          );
+        } else if (chunk.payload === "message" && chunk.message !== void 0) {
+          yield this.convert(() => messageFromProto(chunk.message), method);
+          return;
+        }
+      }
+    } catch (error) {
+      throw this.wrapError(error, method);
+    }
+  }
+};
+export {
+  A2aGrpcMappingError,
+  GrpcClientTransport,
+  startGrpcServer,
+  taskFromProto,
+  taskStateFromProto,
+  taskStateToProto,
+  taskToProto
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./model";
+export * from "./task-store";
+export * from "./executor";
+export * from "./server";
+export * from "./bindings/jsonrpc";
+export * from "./bindings/rest";
+export * from "./client";
+export * from "./backend";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}