@agentlayer.tech/wallet 0.1.101 → 0.1.102

package/connectors/scripts/smoke-packed-packages.mjs

@@ -0,0 +1,121 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const workspaceRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const tempRoot = mkdtempSync(join(tmpdir(), "agentlayer-connector-pack-"));
+
+function run(command, args, cwd = tempRoot) {
+  return execFileSync(command, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+}
+
+function sha256(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+
+try {
+  run("npm", ["pack", join(workspaceRoot, "sdk-typescript"), "--pack-destination", tempRoot]);
+  run("npm", ["pack", join(workspaceRoot, "conformance"), "--pack-destination", tempRoot]);
+  const archives = readdirSync(tempRoot).filter((name) => name.endsWith(".tgz")).sort();
+  if (archives.length !== 2) throw new Error(`Expected two package archives, found ${archives.length}.`);
+
+  const repeatRoot = join(tempRoot, "repeat");
+  mkdirSync(repeatRoot);
+  run("npm", ["pack", join(workspaceRoot, "sdk-typescript"), "--pack-destination", repeatRoot]);
+  run("npm", ["pack", join(workspaceRoot, "conformance"), "--pack-destination", repeatRoot]);
+  for (const archive of archives) {
+    if (sha256(join(tempRoot, archive)) !== sha256(join(repeatRoot, archive))) {
+      throw new Error(`${archive} is not reproducible across consecutive npm pack runs.`);
+    }
+  }
+
+  for (const archive of archives) {
+    const listing = run("tar", ["-tzf", join(tempRoot, archive)]);
+    for (const required of ["package/package.json", "package/README.md", "package/LICENSE"]) {
+      if (!listing.split("\n").includes(required)) {
+        throw new Error(`${archive} is missing ${required}.`);
+      }
+    }
+    if (!listing.split("\n").some((entry) => entry.startsWith("package/dist/") && entry.endsWith(".js"))) {
+      throw new Error(`${archive} is missing compiled JavaScript.`);
+    }
+  }
+
+  run("npm", ["init", "--yes"], tempRoot);
+  const packageJsonPath = join(tempRoot, "package.json");
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  writeFileSync(packageJsonPath, `${JSON.stringify({ ...packageJson, type: "module" }, null, 2)}\n`);
+  run(
+    "npm",
+    [
+      "install",
+      "--ignore-scripts",
+      ...archives.map((archive) => join(tempRoot, archive)),
+      "typescript@7.0.2",
+      "@types/node@24.13.3",
+    ],
+    tempRoot
+  );
+  writeFileSync(
+    join(tempRoot, "consumer.ts"),
+    `import { defineReadOnlyConnector } from "@agentlayer.tech/connector-sdk";
+import { assertFixture } from "@agentlayer.tech/connector-conformance";
+
+assertFixture({ schema_version: 1, tools: { ping: { arguments: {} } } });
+const connector = defineReadOnlyConnector({
+  manifest: {
+    schema_version: 1,
+    id: "com.example.external",
+    name: "External Consumer",
+    version: "1.0.0",
+    publisher: { id: "example", name: "Example" },
+    agentlayer: { protocol_version: 1, runtime_range: ">=0.1.101" },
+    trust: "community_read_only",
+    transport: { type: "https", url: "https://connector.example.com" },
+    permissions: { wallet_address: false, transaction_intents: false, network_hosts: [] },
+    tools: [{
+      name: "ping",
+      description: "Return public health data.",
+      read_only: true,
+      risk_level: "low",
+      input_schema: { type: "object" },
+      output_schema: { type: "object" },
+    }],
+  },
+  handlers: { ping: () => ({ ok: true }) },
+});
+if (connector.manifest.id !== "com.example.external") throw new Error("SDK import failed");
+`,
+    "utf8"
+  );
+  writeFileSync(
+    join(tempRoot, "tsconfig.json"),
+    `${JSON.stringify({
+      compilerOptions: {
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        target: "ES2022",
+        strict: true,
+        types: ["node"],
+        outDir: "dist",
+      },
+      include: ["consumer.ts"],
+    }, null, 2)}\n`,
+    "utf8"
+  );
+  run(join(tempRoot, "node_modules", ".bin", "tsc"), ["-p", "tsconfig.json"]);
+  run(process.execPath, [join(tempRoot, "dist", "consumer.js")]);
+  console.log("smoke-packed-packages: ok");
+} finally {
+  rmSync(tempRoot, { recursive: true, force: true });
+}

package/connectors/sdk-typescript/README.md

@@ -0,0 +1,47 @@
+# AgentLayer Connector SDK
+
+TypeScript types and runtime helpers for AgentLayer Connector Protocol v1.
+
+The initial SDK supports read-only connectors only. It does not expose wallet
+signing, transaction execution, approval tokens, or private wallet material.
+
+```bash
+npm install @agentlayer.tech/connector-sdk@beta
+```
+
+Node.js 24 or newer is required.
+
+## Example
+
+```ts
+import { readFileSync } from "node:fs";
+import {
+  defineReadOnlyConnector,
+  startConnectorServer,
+  type ConnectorManifest,
+} from "@agentlayer.tech/connector-sdk";
+
+const manifest = JSON.parse(
+  readFileSync(new URL("./connector.json", import.meta.url), "utf8")
+) as ConnectorManifest;
+
+const connector = defineReadOnlyConnector({
+  manifest,
+  handlers: {
+    async get_pools(arguments_, context) {
+      return { pools: [] };
+    },
+  },
+});
+
+await startConnectorServer(connector);
+```
+
+`defineReadOnlyConnector` rejects write-capable manifests, undeclared handlers,
+identity drift, invalid arguments, invalid handler output, non-JSON values, and
+response TTLs longer than five minutes. `startConnectorServer` exposes only
+`GET /healthz` and `POST /invoke`, limits request bodies, and returns generic
+errors for unexpected failures.
+
+Use the complete starter in `../templates/read-only` rather than beginning from
+the abbreviated snippet above.

package/connectors/sdk-typescript/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@agentlayer.tech/connector-sdk",
+  "version": "0.1.0-beta.1",
+  "description": "TypeScript SDK for building AgentLayer read-only connectors.",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lopushok9/Agent-Layer.git",
+    "directory": "connectors/sdk-typescript"
+  },
+  "homepage": "https://github.com/lopushok9/Agent-Layer/tree/main/connectors/sdk-typescript#readme",
+  "bugs": {
+    "url": "https://github.com/lopushok9/Agent-Layer/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "sync-license": "node scripts/sync-license.mjs",
+    "build": "tsc -p tsconfig.json",
+    "check": "npm run build && node --test test/*.test.mjs",
+    "prepack": "npm run sync-license && npm run build"
+  },
+  "dependencies": {
+    "ajv": "^8.20.0",
+    "ajv-formats": "^3.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^7.0.2"
+  }
+}

package/connectors/sdk-typescript/scripts/sync-license.mjs

@@ -0,0 +1,3 @@
+import { copyFileSync } from "node:fs";
+
+copyFileSync(new URL("../../../LICENSE", import.meta.url), new URL("../LICENSE", import.meta.url));

package/connectors/sdk-typescript/src/connector.ts

@@ -0,0 +1,204 @@
+import { createRequire } from "node:module";
+
+import { Ajv, type ValidateFunction } from "ajv";
+import type { FormatsPlugin } from "ajv-formats";
+
+import { ConnectorSdkError } from "./errors.js";
+import type {
+  ConnectorInvocationRequest,
+  ConnectorManifest,
+  ConnectorReadResponse,
+  ConnectorToolManifest,
+  JsonValue,
+  ReadOnlyConnector,
+  ReadOnlyConnectorDefinition,
+} from "./types.js";
+
+const TOOL_NAME_PATTERN = /^[a-z][a-z0-9_]{0,63}$/;
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+const MAX_RESPONSE_TTL_SECONDS = 300;
+const RESERVED_WRITE_RESULT_KEYS = new Set([
+  "approval_token",
+  "broadcast_request",
+  "evm_transaction_intent",
+  "payment_intent",
+  "raw_transaction",
+  "signed_transaction",
+  "signing_request",
+  "solana_transaction_intent",
+  "transaction_intent",
+]);
+const READ_ONLY_TRUST = new Set([
+  "community_read_only",
+  "verified_read_only",
+  "local_development",
+]);
+const require = createRequire(import.meta.url);
+const addFormats = require("ajv-formats") as FormatsPlugin;
+
+interface CompiledTool {
+  manifest: ConnectorToolManifest;
+  validateInput: ValidateFunction;
+  validateOutput: ValidateFunction;
+}
+
+function fail(code: string, message: string, statusCode = 400): never {
+  throw new ConnectorSdkError(code, message, statusCode);
+}
+
+function assertJsonValue(value: unknown, path = "result"): asserts value is JsonValue {
+  if (value === null || ["string", "number", "boolean"].includes(typeof value)) {
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      fail("invalid_json", `${path} contains a non-finite number.`, 500);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertJsonValue(item, `${path}[${index}]`));
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      if (RESERVED_WRITE_RESULT_KEYS.has(key.toLowerCase())) {
+        fail("write_not_supported", `${path} contains reserved write field: ${key}.`, 500);
+      }
+      assertJsonValue(item, `${path}.${key}`);
+    }
+    return;
+  }
+  fail("invalid_json", `${path} is not JSON-serializable.`, 500);
+}
+
+function assertManifest(definition: ReadOnlyConnectorDefinition): void {
+  const { manifest, handlers } = definition;
+  if (manifest.schema_version !== 1 || manifest.agentlayer?.protocol_version !== 1) {
+    fail("invalid_manifest", "Connector must use manifest and protocol version 1.");
+  }
+  if (!READ_ONLY_TRUST.has(manifest.trust)) {
+    fail("write_not_supported", "The TypeScript SDK currently accepts read-only connectors only.");
+  }
+  if (manifest.permissions?.transaction_intents !== false) {
+    fail("write_not_supported", "Read-only connectors must disable transaction_intents.");
+  }
+  if (!Array.isArray(manifest.tools) || manifest.tools.length === 0) {
+    fail("invalid_manifest", "Connector manifest must declare at least one tool.");
+  }
+  const names = new Set<string>();
+  for (const tool of manifest.tools) {
+    if (!TOOL_NAME_PATTERN.test(tool.name)) {
+      fail("invalid_manifest", `Invalid connector tool name: ${tool.name}.`);
+    }
+    if (names.has(tool.name)) {
+      fail("invalid_manifest", `Duplicate connector tool name: ${tool.name}.`);
+    }
+    names.add(tool.name);
+    if (tool.read_only !== true) {
+      fail("write_not_supported", `Tool ${tool.name} is not read-only.`);
+    }
+    if (typeof handlers[tool.name] !== "function") {
+      fail("missing_handler", `Missing handler for connector tool: ${tool.name}.`);
+    }
+  }
+  for (const handlerName of Object.keys(handlers)) {
+    if (!names.has(handlerName)) {
+      fail("unknown_handler", `Handler is not declared in the manifest: ${handlerName}.`);
+    }
+  }
+}
+
+function assertRequestIdentity(
+  request: ConnectorInvocationRequest,
+  manifest: ConnectorManifest
+): void {
+  if (request.protocol_version !== 1) {
+    fail("protocol_mismatch", "Unsupported connector protocol version.");
+  }
+  if (typeof request.request_id !== "string" || request.request_id.length < 8) {
+    fail("invalid_request", "request_id is required.");
+  }
+  if (
+    request.connector?.id !== manifest.id ||
+    request.connector?.version !== manifest.version ||
+    request.connector?.artifact_digest !== manifest.artifact_digest
+  ) {
+    fail("identity_mismatch", "Connector request identity does not match this deployment.", 409);
+  }
+  if (!request.arguments || Array.isArray(request.arguments) || typeof request.arguments !== "object") {
+    fail("invalid_request", "Connector arguments must be an object.");
+  }
+  if (!request.context || Array.isArray(request.context) || typeof request.context !== "object") {
+    fail("invalid_request", "Connector context must be an object.");
+  }
+  if (request.expires_at) {
+    const expiry = Date.parse(request.expires_at);
+    if (!Number.isFinite(expiry) || expiry <= Date.now()) {
+      fail("expired_request", "Connector request is expired.");
+    }
+  }
+}
+
+export function defineReadOnlyConnector(
+  definition: ReadOnlyConnectorDefinition
+): ReadOnlyConnector {
+  assertManifest(definition);
+  const ttlSeconds = definition.responseTtlSeconds ?? 60;
+  if (!Number.isInteger(ttlSeconds) || ttlSeconds < 1 || ttlSeconds > MAX_RESPONSE_TTL_SECONDS) {
+    fail("invalid_ttl", `responseTtlSeconds must be between 1 and ${MAX_RESPONSE_TTL_SECONDS}.`);
+  }
+
+  const ajv = new Ajv({ allErrors: true, strict: true });
+  addFormats(ajv);
+  const tools = new Map<string, CompiledTool>();
+  try {
+    for (const tool of definition.manifest.tools) {
+      tools.set(tool.name, {
+        manifest: tool,
+        validateInput: ajv.compile(tool.input_schema),
+        validateOutput: ajv.compile(tool.output_schema),
+      });
+    }
+  } catch (error) {
+    fail("invalid_schema", `Connector tool schema is invalid: ${String(error)}`);
+  }
+
+  const manifest = structuredClone(definition.manifest);
+  return Object.freeze({
+    manifest: Object.freeze(manifest),
+    async invoke(request: ConnectorInvocationRequest): Promise<ConnectorReadResponse> {
+      assertRequestIdentity(request, manifest);
+      const tool = tools.get(request.tool);
+      if (!tool) {
+        fail("unknown_tool", `Connector tool is not declared: ${request.tool}.`, 404);
+      }
+      if (!tool.validateInput(request.arguments)) {
+        fail("invalid_arguments", `Arguments do not match the schema for ${request.tool}.`);
+      }
+      const result: unknown = await definition.handlers[request.tool]!(
+        request.arguments,
+        Object.freeze({ ...request.context })
+      );
+      assertJsonValue(result);
+      if (!tool.validateOutput(result)) {
+        fail("invalid_result", `Result does not match the schema for ${request.tool}.`, 500);
+      }
+      const connector = {
+        id: manifest.id,
+        version: manifest.version,
+        ...(manifest.artifact_digest ? { artifact_digest: manifest.artifact_digest } : {}),
+      };
+      const response: ConnectorReadResponse = {
+        protocol_version: 1,
+        request_id: request.request_id,
+        connector,
+        tool: request.tool,
+        kind: "read_result",
+        result,
+        expires_at: new Date(Date.now() + ttlSeconds * 1000).toISOString(),
+      };
+      if (Buffer.byteLength(JSON.stringify(response)) > MAX_RESPONSE_BYTES) {
+        fail("response_too_large", "Connector response exceeds the 1 MiB protocol limit.", 500);
+      }
+      return response;
+    },
+  });
+}

package/connectors/sdk-typescript/src/errors.ts

@@ -0,0 +1,11 @@
+export class ConnectorSdkError extends Error {
+  readonly code: string;
+  readonly statusCode: number;
+
+  constructor(code: string, message: string, statusCode = 400) {
+    super(message);
+    this.name = "ConnectorSdkError";
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+}

package/connectors/sdk-typescript/src/http.ts

@@ -0,0 +1,116 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+
+import { ConnectorSdkError } from "./errors.js";
+import type { ConnectorInvocationRequest, ReadOnlyConnector } from "./types.js";
+
+const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
+
+export interface ConnectorHttpOptions {
+  maxBodyBytes?: number;
+}
+
+export interface StartConnectorServerOptions extends ConnectorHttpOptions {
+  host?: string;
+  port?: number;
+}
+
+function sendJson(response: ServerResponse, statusCode: number, payload: unknown): void {
+  const body = JSON.stringify(payload);
+  response.writeHead(statusCode, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(body),
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff",
+  });
+  response.end(body);
+}
+
+async function readJson(request: IncomingMessage, maxBodyBytes: number): Promise<unknown> {
+  const contentLength = Number(request.headers["content-length"] ?? 0);
+  if (Number.isFinite(contentLength) && contentLength > maxBodyBytes) {
+    throw new ConnectorSdkError("request_too_large", "Request body exceeds the size limit.", 413);
+  }
+  const chunks: Buffer[] = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > maxBodyBytes) {
+      throw new ConnectorSdkError("request_too_large", "Request body exceeds the size limit.", 413);
+    }
+    chunks.push(buffer);
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new ConnectorSdkError("invalid_json", "Request body must be valid JSON.");
+  }
+}
+
+export function createConnectorHttpHandler(
+  connector: ReadOnlyConnector,
+  options: ConnectorHttpOptions = {}
+): (request: IncomingMessage, response: ServerResponse) => Promise<void> {
+  const maxBodyBytes = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+  if (!Number.isInteger(maxBodyBytes) || maxBodyBytes < 1024) {
+    throw new ConnectorSdkError("invalid_http_options", "maxBodyBytes must be at least 1024.");
+  }
+  return async (request, response) => {
+    try {
+      if (request.method === "GET" && request.url === "/healthz") {
+        sendJson(response, 200, {
+          ok: true,
+          connector: {
+            id: connector.manifest.id,
+            version: connector.manifest.version,
+          },
+        });
+        return;
+      }
+      if (request.method !== "POST" || request.url !== "/invoke") {
+        sendJson(response, 404, { ok: false, error: { code: "not_found", message: "Not found." } });
+        return;
+      }
+      if (!String(request.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
+        throw new ConnectorSdkError("unsupported_media_type", "Content-Type must be application/json.", 415);
+      }
+      const payload = await readJson(request, maxBodyBytes);
+      const result = await connector.invoke(payload as ConnectorInvocationRequest);
+      sendJson(response, 200, result);
+    } catch (error) {
+      const sdkError =
+        error instanceof ConnectorSdkError
+          ? error
+          : new ConnectorSdkError("internal_error", "Connector invocation failed.", 500);
+      sendJson(response, sdkError.statusCode, {
+        ok: false,
+        error: { code: sdkError.code, message: sdkError.message },
+      });
+    }
+  };
+}
+
+export async function startConnectorServer(
+  connector: ReadOnlyConnector,
+  options: StartConnectorServerOptions = {}
+): Promise<Server> {
+  const handler = createConnectorHttpHandler(connector, options);
+  const host = options.host ?? "0.0.0.0";
+  const port = options.port ?? Number(process.env.PORT ?? 3000);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new ConnectorSdkError("invalid_http_options", "port must be between 1 and 65535.");
+  }
+  const server = createServer((request, response) => void handler(request, response));
+  server.requestTimeout = DEFAULT_REQUEST_TIMEOUT_MS;
+  server.headersTimeout = 10_000;
+  server.keepAliveTimeout = 5_000;
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  return server;
+}

package/connectors/sdk-typescript/src/index.ts

@@ -0,0 +1,26 @@
+export { defineReadOnlyConnector } from "./connector.js";
+export { ConnectorSdkError } from "./errors.js";
+export {
+  createConnectorHttpHandler,
+  startConnectorServer,
+  type ConnectorHttpOptions,
+  type StartConnectorServerOptions,
+} from "./http.js";
+
+export type {
+  ConnectorIdentity,
+  ConnectorInvocationContext,
+  ConnectorInvocationRequest,
+  ConnectorManifest,
+  ConnectorReadHandler,
+  ConnectorReadHandlers,
+  ConnectorReadResponse,
+  ConnectorToolManifest,
+  ConnectorTrust,
+  JsonObject,
+  JsonPrimitive,
+  JsonSchema,
+  JsonValue,
+  ReadOnlyConnector,
+  ReadOnlyConnectorDefinition,
+} from "./types.js";

package/connectors/sdk-typescript/src/types.ts

@@ -0,0 +1,101 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+export type JsonObject = { [key: string]: JsonValue };
+export type JsonSchema = Record<string, unknown>;
+
+export type ConnectorTrust =
+  | "community_read_only"
+  | "verified_read_only"
+  | "verified_write"
+  | "local_development";
+
+export interface ConnectorToolManifest {
+  name: string;
+  description: string;
+  read_only: boolean;
+  risk_level: "low" | "medium" | "high";
+  input_schema: JsonSchema;
+  output_schema: JsonSchema;
+}
+
+export interface ConnectorManifest {
+  schema_version: 1;
+  id: string;
+  name: string;
+  version: string;
+  artifact_digest?: string;
+  publisher: {
+    id: string;
+    name: string;
+    url?: string;
+  };
+  agentlayer: {
+    protocol_version: 1;
+    runtime_range: string;
+  };
+  trust: ConnectorTrust;
+  transport: {
+    type: "https";
+    url: string;
+    timeout_ms?: number;
+  };
+  permissions: {
+    wallet_address: boolean;
+    transaction_intents: boolean;
+    network_hosts: string[];
+  };
+  tools: ConnectorToolManifest[];
+}
+
+export interface ConnectorIdentity {
+  id: string;
+  version: string;
+  artifact_digest?: string;
+}
+
+export interface ConnectorInvocationContext {
+  chain?: string;
+  network?: string;
+  chain_id?: string | number;
+  wallet_address?: string;
+}
+
+export interface ConnectorInvocationRequest {
+  protocol_version: 1;
+  request_id: string;
+  connector: ConnectorIdentity;
+  tool: string;
+  arguments: JsonObject;
+  context: ConnectorInvocationContext;
+  issued_at?: string;
+  expires_at?: string;
+  nonce?: string;
+}
+
+export interface ConnectorReadResponse {
+  protocol_version: 1;
+  request_id: string;
+  connector: ConnectorIdentity;
+  tool: string;
+  kind: "read_result";
+  result: JsonValue;
+  expires_at: string;
+}
+
+export type ConnectorReadHandler = (
+  arguments_: JsonObject,
+  context: Readonly<ConnectorInvocationContext>
+) => JsonValue | Promise<JsonValue>;
+
+export type ConnectorReadHandlers = Record<string, ConnectorReadHandler>;
+
+export interface ReadOnlyConnectorDefinition {
+  manifest: ConnectorManifest;
+  handlers: ConnectorReadHandlers;
+  responseTtlSeconds?: number;
+}
+
+export interface ReadOnlyConnector {
+  readonly manifest: Readonly<ConnectorManifest>;
+  invoke(request: ConnectorInvocationRequest): Promise<ConnectorReadResponse>;
+}