nexus-ai-pro 2.19.0 → 2.20.2

package/dist/evaluate/emulate.js

@@ -1,4 +1,53 @@
+import { capabilitiesOf, parseCapability } from '../agent/capabilities.js';
 import { sha256Hex } from '../utils/sha256.js';
+export class EmulatedWorld {
+    scenario;
+    log;
+    constructor(start = {}) {
+        if (start.scenario !== undefined)
+            this.scenario = start.scenario;
+        this.log = JSON.parse(JSON.stringify(start.calls ?? []));
+    }
+    get calls() {
+        return JSON.parse(JSON.stringify(this.log));
+    }
+    get changes() {
+        return JSON.parse(JSON.stringify(this.log.filter((call) => call.changed)));
+    }
+    record(call, changed) {
+        this.log.push({ ...JSON.parse(JSON.stringify(call)), changed });
+    }
+    digest() {
+        return sha256Hex(canonical({
+            scenario: this.scenario ?? '',
+            changes: this.changes.map((call) => ({ tool: call.tool, args: call.args, result: call.result ?? null })),
+        }));
+    }
+    ordinal(tool, args) {
+        const identity = canonical(args);
+        let count = 0;
+        for (let index = this.log.length - 1; index >= 0; index -= 1) {
+            const call = this.log[index];
+            if (call.changed)
+                break;
+            if (call.tool === tool && canonical(call.args) === identity)
+                count += 1;
+        }
+        return count;
+    }
+    snapshot() {
+        return {
+            ...(this.scenario !== undefined ? { scenario: this.scenario } : {}),
+            calls: JSON.parse(JSON.stringify(this.log)),
+        };
+    }
+    fork() {
+        return new EmulatedWorld(this.snapshot());
+    }
+    toJSON() {
+        return this.snapshot();
+    }
+}
 export class EmulationError extends Error {
     code;
     tool;
@@ -30,7 +79,23 @@ export class MemoryEmulationStore {
     }
 }
 export function emulationKey(call) {
-    return sha256Hex(canonical({ tool: call.tool, args: call.args, scenario: call.scenario ?? '', ordinal: call.ordinal ?? 0 }));
+    return sha256Hex(canonical({
+        tool: call.tool,
+        args: call.args,
+        scenario: call.scenario ?? '',
+        ordinal: call.ordinal ?? 0,
+        ...(call.world !== undefined ? { world: call.world } : {}),
+    }));
+}
+function onlyReads(definition, args, reads) {
+    if (reads.has(definition.name))
+        return true;
+    const declared = capabilitiesOf(definition, args);
+    if (declared === undefined)
+        return false;
+    const parsed = declared.map((capability) => parseCapability(capability));
+    const isRead = (item) => (item.kind === 'filesystem' && item.access === 'read') || item.kind === 'mcp.read' || item.kind === 'api.read';
+    return (parsed.every((item) => isRead(item) || item.kind === 'network') && (parsed.length === 0 || parsed.some(isRead)));
 }
 export function emulatedTools(tools, options) {
     const mode = options.mode ?? (options.store ? 'auto' : 'emulate');
@@ -40,6 +105,10 @@ export function emulatedTools(tools, options) {
     const limit = Math.max(0, options.history ?? 20);
     const history = [];
     const ordinals = new Map();
+    const world = options.world;
+    const reads = new Set(options.reads ?? []);
+    const scenario = options.scenario ?? world?.scenario;
+    const told = scenario === options.scenario ? options : { ...options, scenario };
     const report = (call) => {
         try {
             options.onCall?.(call);
@@ -47,6 +116,18 @@ export function emulatedTools(tools, options) {
         catch {
         }
     };
+    const earlier = () => {
+        if (!world)
+            return limit === 0 ? [] : history.slice(-limit);
+        const calls = world.calls;
+        return calls
+            .filter((call, index) => call.changed || index >= calls.length - limit)
+            .map(({ changed: _changed, ...call }) => call);
+    };
+    const remember = (definition, answer) => {
+        history.push(answer);
+        world?.record(answer, answer.error === undefined && !onlyReads(definition, answer.args, reads));
+    };
     return tools.map((definition) => {
         const { execute: run, stream, ...shape } = definition;
         if (passthrough.has(definition.name)) {
@@ -55,13 +136,20 @@ export function emulatedTools(tools, options) {
             return {
                 ...shape,
                 execute: async (args, context) => {
-                    const key = emulationKey({ tool: definition.name, args, scenario: options.scenario });
+                    const key = emulationKey({
+                        tool: definition.name,
+                        args,
+                        scenario,
+                        ...(world ? { world: world.digest() } : {}),
+                    });
                     try {
                         const result = run ? await run(args, context) : await drain(definition, args, context);
+                        remember(definition, { tool: definition.name, args, result });
                         report({ tool: definition.name, args, result, source: 'real', key });
                         return result;
                     }
                     catch (error) {
+                        remember(definition, { tool: definition.name, args, error: messageOf(error) });
                         report({ tool: definition.name, args, error: messageOf(error), source: 'real', key });
                         throw error;
                     }
@@ -71,10 +159,22 @@ export function emulatedTools(tools, options) {
         return {
             ...shape,
             execute: async (args, context) => {
-                const identity = `${definition.name}\u0000${canonical(args)}`;
-                const ordinal = ordinals.get(identity) ?? 0;
-                ordinals.set(identity, ordinal + 1);
-                const key = emulationKey({ tool: definition.name, args, scenario: options.scenario, ordinal });
+                let ordinal;
+                if (world) {
+                    ordinal = world.ordinal(definition.name, args);
+                }
+                else {
+                    const identity = `${definition.name}\u0000${canonical(args)}`;
+                    ordinal = ordinals.get(identity) ?? 0;
+                    ordinals.set(identity, ordinal + 1);
+                }
+                const key = emulationKey({
+                    tool: definition.name,
+                    args,
+                    scenario,
+                    ordinal,
+                    ...(world ? { world: world.digest() } : {}),
+                });
                 let answer;
                 let source = 'store';
                 if (mode === 'auto' || mode === 'replay')
@@ -83,12 +183,12 @@ export function emulatedTools(tools, options) {
                     if (mode === 'replay') {
                         throw new EmulationError('EMULATION_MISS', definition.name, args, `No kept answer for ${definition.name}(${canonical(args)}), call ${ordinal + 1}: record it first`);
                     }
-                    answer = await emulate(definition, args, context, limit === 0 ? [] : history.slice(-limit), options);
+                    answer = await emulate(definition, args, context, earlier(), told, world !== undefined);
                     source = 'model';
                     if (mode !== 'emulate')
                         await options.store?.set(key, answer);
                 }
-                history.push(answer);
+                remember(definition, answer);
                 report({
                     tool: definition.name,
                     args,
@@ -103,9 +203,9 @@ export function emulatedTools(tools, options) {
         };
     });
 }
-async function emulate(definition, args, context, earlier, options) {
+async function emulate(definition, args, context, earlier, options, inWorld) {
     const messages = [
-        { role: 'system', content: brief(definition, earlier, options) },
+        { role: 'system', content: brief(definition, earlier, options, inWorld) },
         { role: 'user', content: `Arguments: ${JSON.stringify(args)}` },
     ];
     let problem = '';
@@ -136,7 +236,7 @@ async function emulate(definition, args, context, earlier, options) {
     }
     throw new EmulationError('EMULATION_INVALID', definition.name, args, `The emulator gave no usable answer for ${definition.name}: ${problem}`);
 }
-function brief(definition, earlier, options) {
+function brief(definition, earlier, options, inWorld) {
     const lines = [
         `You are emulating the tool "${definition.name}" for a test, in place of the real one.`,
         'Reply with exactly what the real tool would return for the arguments you are given, as JSON:',
@@ -163,7 +263,9 @@ function brief(definition, earlier, options) {
         }
     }
     if (earlier.length > 0) {
-        lines.push('', 'Earlier calls in this run, oldest first:');
+        lines.push('', inWorld
+            ? 'What has happened in this world, oldest first: every change made in it, and the latest calls. Answer as the world now is.'
+            : 'Earlier calls in this run, oldest first:');
         for (const call of earlier) {
             const outcome = call.error === undefined ? `returned ${JSON.stringify(call.result)}` : `failed: ${call.error}`;
             lines.push(`- ${call.tool} ${JSON.stringify(call.args)} ${outcome}`);

package/dist/optimizer/densifier.js

@@ -1,3 +1,12 @@
+const PHRASES = [
+    [/\bplease make sure that\b/gi, 'ensure'],
+    [/\byou should\b/gi, 'do'],
+    [/\bit is important to\b/gi, 'must'],
+    [/\bin order to\b/gi, 'to'],
+    [/\bdue to the fact that\b/gi, 'because'],
+    [/\bat this point in time\b/gi, 'now'],
+    [/\bas soon as possible\b/gi, 'ASAP'],
+];
 export class PromptDensifier {
     densifyRequest(request, config = {}) {
         if (config.enabled === false)
@@ -19,7 +28,7 @@ export class PromptDensifier {
     }
     densifyText(text, techniques, applied, config) {
         const segments = this.splitCodeBlocks(text, config.preserveCodeBlocks !== false);
-        return segments
+        const joined = segments
             .map((segment) => {
             if (segment.type === 'code')
                 return segment.value;
@@ -29,21 +38,15 @@ export class PromptDensifier {
                 output = output
                     .replace(/[ \t]+/g, ' ')
                     .replace(/\n{3,}/g, '\n\n')
-                    .replace(/[ \t]+\n/g, '\n')
-                    .trim();
+                    .replace(/[ \t]+\n/g, '\n');
                 if (output !== before)
                     applied.add('whitespace-cleanup');
             }
             if (techniques.includes('phrase-compression')) {
                 const before = output;
-                output = output
-                    .replace(/please make sure that/gi, 'ensure')
-                    .replace(/you should/gi, 'do')
-                    .replace(/it is important to/gi, 'must')
-                    .replace(/in order to/gi, 'to')
-                    .replace(/due to the fact that/gi, 'because')
-                    .replace(/at this point in time/gi, 'now')
-                    .replace(/as soon as possible/gi, 'ASAP');
+                for (const [phrase, shorter] of PHRASES) {
+                    output = output.replace(phrase, (match) => /^[A-Z]/.test(match) ? `${shorter.charAt(0).toUpperCase()}${shorter.slice(1)}` : shorter);
+                }
                 if (output !== before)
                     applied.add('phrase-compression');
             }
@@ -56,6 +59,12 @@ export class PromptDensifier {
             return output;
         })
             .join('');
+        if (!techniques.includes('whitespace-cleanup'))
+            return joined;
+        const trimmed = joined.trim();
+        if (trimmed !== joined)
+            applied.add('whitespace-cleanup');
+        return trimmed;
     }
     splitCodeBlocks(text, preserveCodeBlocks) {
         if (!preserveCodeBlocks)

package/dist/protocols/a2a-grpc.js

@@ -258,7 +258,7 @@ export function a2aGrpcClient(options) {
         });
         const abort = () => request.close(http2.constants.NGHTTP2_CANCEL);
         signal?.addEventListener('abort', abort, { once: true });
-        request.end(frame(encodeA2a(shape.request, params)));
+        request.end(frame(encodeA2a(shape.request, options.tenant ? { tenant: options.tenant, ...params } : params)));
         let status = {};
         request.on('response', (headers) => {
             if (headers['grpc-status'] !== undefined)

package/dist/protocols/a2a-proto.d.ts

@@ -2,8 +2,8 @@
  * A2A's messages in Protocol Buffers, as `specification/a2a.proto` of protocol 1.0 numbers them
  * (package `lf.a2a.v1`): each turned into, and read from, the JSON the other bindings carry, so the
  * gRPC binding calls the same methods with the same params. With `google.protobuf.Struct`, `Value`,
- * `Timestamp`, and `google.rpc.Status`. Fields the agent never sends, such as a card's security
- * schemes, are read past and not written.
+ * `Timestamp`, and `google.rpc.Status`. A card's security schemes, requirements, and signatures are
+ * written and read as the card's JSON has them.
  */
 /** Each method of `lf.a2a.v1.A2AService`: what it takes, what it answers, and whether it streams. */
 export declare const A2A_GRPC_METHODS: Readonly<Record<string, {

package/dist/protocols/a2a-proto.js

@@ -95,11 +95,56 @@ const MESSAGES = {
         f('version', 5, 'string'),
         f('documentationUrl', 6, 'string', present),
         f('capabilities', 7, { message: 'AgentCapabilities' }),
+        f('securitySchemes', 8, { map: 'SecurityScheme' }),
+        f('securityRequirements', 9, { message: 'SecurityRequirement' }, many),
         f('defaultInputModes', 10, 'string', all),
         f('defaultOutputModes', 11, 'string', all),
         f('skills', 12, { message: 'AgentSkill' }, all),
+        f('signatures', 13, { message: 'AgentCardSignature' }, many),
         f('iconUrl', 14, 'string', present),
     ],
+    AgentCardSignature: [f('protected', 1, 'string'), f('signature', 2, 'string'), f('header', 3, 'struct')],
+    StringList: [f('list', 1, 'string', all)],
+    SecurityRequirement: [f('schemes', 1, { map: 'StringList' })],
+    SecurityScheme: [
+        f('apiKeySecurityScheme', 1, { message: 'APIKeySecurityScheme' }),
+        f('httpAuthSecurityScheme', 2, { message: 'HTTPAuthSecurityScheme' }),
+        f('oauth2SecurityScheme', 3, { message: 'OAuth2SecurityScheme' }),
+        f('openIdConnectSecurityScheme', 4, { message: 'OpenIdConnectSecurityScheme' }),
+        f('mtlsSecurityScheme', 5, { message: 'MutualTlsSecurityScheme' }),
+    ],
+    APIKeySecurityScheme: [f('description', 1, 'string'), f('location', 2, 'string'), f('name', 3, 'string')],
+    HTTPAuthSecurityScheme: [f('description', 1, 'string'), f('scheme', 2, 'string'), f('bearerFormat', 3, 'string')],
+    OAuth2SecurityScheme: [
+        f('description', 1, 'string'),
+        f('flows', 2, { message: 'OAuthFlows' }),
+        f('oauth2MetadataUrl', 3, 'string'),
+    ],
+    OpenIdConnectSecurityScheme: [f('description', 1, 'string'), f('openIdConnectUrl', 2, 'string')],
+    MutualTlsSecurityScheme: [f('description', 1, 'string')],
+    OAuthFlows: [
+        f('authorizationCode', 1, { message: 'AuthorizationCodeOAuthFlow' }),
+        f('clientCredentials', 2, { message: 'ClientCredentialsOAuthFlow' }),
+        f('implicit', 3, { message: 'ImplicitOAuthFlow' }),
+        f('password', 4, { message: 'PasswordOAuthFlow' }),
+        f('deviceCode', 5, { message: 'DeviceCodeOAuthFlow' }),
+    ],
+    AuthorizationCodeOAuthFlow: [
+        f('authorizationUrl', 1, 'string'),
+        f('tokenUrl', 2, 'string'),
+        f('refreshUrl', 3, 'string'),
+        f('scopes', 4, 'stringMap'),
+        f('pkceRequired', 5, 'bool'),
+    ],
+    ClientCredentialsOAuthFlow: [f('tokenUrl', 1, 'string'), f('refreshUrl', 2, 'string'), f('scopes', 3, 'stringMap')],
+    ImplicitOAuthFlow: [f('authorizationUrl', 1, 'string'), f('refreshUrl', 2, 'string'), f('scopes', 3, 'stringMap')],
+    PasswordOAuthFlow: [f('tokenUrl', 1, 'string'), f('refreshUrl', 2, 'string'), f('scopes', 3, 'stringMap')],
+    DeviceCodeOAuthFlow: [
+        f('deviceAuthorizationUrl', 1, 'string'),
+        f('tokenUrl', 2, 'string'),
+        f('refreshUrl', 3, 'string'),
+        f('scopes', 4, 'stringMap'),
+    ],
     AgentProvider: [f('url', 1, 'string'), f('organization', 2, 'string')],
     AgentCapabilities: [
         f('streaming', 1, 'bool', present),
@@ -121,6 +166,7 @@ const MESSAGES = {
         f('examples', 5, 'string', many),
         f('inputModes', 6, 'string', many),
         f('outputModes', 7, 'string', many),
+        f('securityRequirements', 8, { message: 'SecurityRequirement' }, many),
     ],
     TaskPushNotificationConfig: [
         f('tenant', 1, 'string'),
@@ -337,6 +383,21 @@ function writeField(writer, field, item, always) {
             writer.bytes(inner.finish());
         }
     }
+    else if ('map' in type) {
+        if (typeof item !== 'object' || item === null || Array.isArray(item))
+            return;
+        for (const [key, entry] of Object.entries(item)) {
+            const inner = new Writer();
+            inner.tag(1, 2);
+            inner.bytes(utf8.encode(key));
+            const value = new Writer();
+            writeMessage(value, type.map, (entry ?? {}));
+            inner.tag(2, 2);
+            inner.bytes(value.finish());
+            writer.tag(field.number, 2);
+            writer.bytes(inner.finish());
+        }
+    }
     else if ('enum' in type) {
         const index = typeof item === 'number' ? item : type.enum.indexOf(String(item));
         if (index < 0 || (!always && index === 0))
@@ -456,8 +517,9 @@ export function decodeA2a(type, bytes) {
         const value = readField(field, raw);
         if (value === undefined)
             continue;
-        if (field.type === 'stringMap')
+        if (field.type === 'stringMap' || (typeof field.type === 'object' && 'map' in field.type)) {
             out[field.json] = { ...out[field.json], ...value };
+        }
         else if (field.repeated) {
             const list = out[field.json] ?? [];
             list.push(value);
@@ -511,6 +573,19 @@ function readField(field, raw) {
         }
         return { [key]: value };
     }
+    if ('map' in type) {
+        if (!raw.bytes)
+            return undefined;
+        let key = '';
+        let value = new Uint8Array();
+        for (const inner of rawFields(raw.bytes)) {
+            if (inner.number === 1 && inner.bytes)
+                key = fromUtf8.decode(inner.bytes);
+            if (inner.number === 2 && inner.bytes)
+                value = inner.bytes;
+        }
+        return { [key]: decodeA2a(type.map, value) };
+    }
     if ('enum' in type) {
         if (raw.varint === undefined)
             return undefined;

package/dist/protocols/a2a.d.ts

@@ -69,6 +69,86 @@ export interface A2aTask {
     /** Anything else. */
     metadata?: Record<string, unknown>;
 }
+/** One of the OAuth 2.0 flows an `oauth2SecurityScheme` offers: exactly one is set. */
+export type A2aOAuthFlows = {
+    authorizationCode: {
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: Record<string, string>;
+        pkceRequired?: boolean;
+    };
+} | {
+    clientCredentials: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: Record<string, string>;
+    };
+} | {
+    deviceCode: {
+        deviceAuthorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: Record<string, string>;
+    };
+} | {
+    implicit: {
+        authorizationUrl?: string;
+        refreshUrl?: string;
+        scopes?: Record<string, string>;
+    };
+} | {
+    password: {
+        tokenUrl?: string;
+        refreshUrl?: string;
+        scopes?: Record<string, string>;
+    };
+};
+/** How a caller authenticates with an agent, as its card names it: exactly one scheme is set. */
+export type A2aSecurityScheme = {
+    apiKeySecurityScheme: {
+        description?: string;
+        location: 'query' | 'header' | 'cookie';
+        name: string;
+    };
+} | {
+    httpAuthSecurityScheme: {
+        description?: string;
+        scheme: string;
+        bearerFormat?: string;
+    };
+} | {
+    oauth2SecurityScheme: {
+        description?: string;
+        flows: A2aOAuthFlows;
+        oauth2MetadataUrl?: string;
+    };
+} | {
+    openIdConnectSecurityScheme: {
+        description?: string;
+        openIdConnectUrl: string;
+    };
+} | {
+    mtlsSecurityScheme: {
+        description?: string;
+    };
+};
+/** The schemes a call needs, by the names the card gives them, each with the scopes it needs. */
+export interface A2aSecurityRequirement {
+    /** Each scheme's name, with its scopes. */
+    schemes: Record<string, {
+        list: string[];
+    }>;
+}
+/** A JSON Web Signature over an agent card, as the card carries it. */
+export interface A2aCardSignature {
+    /** The protected header: base64url-encoded JSON. */
+    protected: string;
+    /** The signature, base64url-encoded. */
+    signature: string;
+    /** The unprotected header's values. */
+    header?: Record<string, unknown>;
+}
 /** A skill an agent card advertises. */
 export interface A2aSkill {
     /** Its id. */
@@ -81,6 +161,8 @@ export interface A2aSkill {
     tags: string[];
     /** Example requests. */
     examples?: string[];
+    /** The schemes a call of this skill needs, beyond the card's. */
+    securityRequirements?: A2aSecurityRequirement[];
 }
 /** What an agent publishes about itself at `/.well-known/agent-card.json`. */
 export interface A2aAgentCard {
@@ -114,6 +196,12 @@ export interface A2aAgentCard {
     defaultOutputModes: string[];
     /** What it can do. */
     skills: A2aSkill[];
+    /** How a caller authenticates, each scheme by a name `securityRequirements` use. */
+    securitySchemes?: Record<string, A2aSecurityScheme>;
+    /** The schemes a call needs. */
+    securityRequirements?: A2aSecurityRequirement[];
+    /** Signatures over the card, as given: a signature must be over the card as it is served. */
+    signatures?: A2aCardSignature[];
 }
 /** A streamed event: a task, a status change, or a piece of an artifact. */
 export type A2aStreamEvent = {
@@ -143,6 +231,11 @@ export declare const A2A_ERRORS: {
     readonly unsupportedOperation: -32004;
     readonly extendedCardNotConfigured: -32007;
     readonly versionNotSupported: -32009;
+    /**
+     * This package's own, from the range JSON-RPC leaves to servers: the caller may not act for the
+     * tenant it named. HTTP 403, and `PERMISSION_DENIED` over gRPC.
+     */
+    readonly permissionDenied: -32099;
 };
 /** Raised by a client when an agent answers with an error, on any binding, as A2A's code. */
 export declare class A2aError extends Error {
@@ -191,6 +284,8 @@ export interface A2aTaskRecord {
     run?: A2aTaskRun;
     /** Bumped by every claim of the lease, so two replicas claiming one task cannot both win. */
     version?: number;
+    /** The tenant it belongs to, when the handler serves several: no other tenant's request sees it. */
+    tenant?: string;
 }
 /** A replica's hold on a working task. */
 export interface A2aTaskLease {
@@ -216,6 +311,8 @@ export interface A2aTaskQuery {
     contextId?: string;
     /** Only those in this state. */
     state?: A2aTaskState;
+    /** Only this tenant's. A store that serves several tenants must honour it. */
+    tenant?: string;
     /** Most returned. */
     limit: number;
     /** Skipped first, for paging. */
@@ -314,6 +411,16 @@ export interface A2aPushOptions {
         everyMs?: number;
     };
 }
+/** How one handler serves several tenants, each request routed by the `tenant` it names. */
+export interface A2aTenancyOptions {
+    /**
+     * Whether a caller may act for the tenant its request names. Defaults to its principal's `tenantId`
+     * being that tenant, so a caller nobody authenticated may act for none.
+     */
+    authorize?: (tenant: string, principal: Principal | undefined) => boolean | Promise<boolean>;
+    /** Whether every request must name a tenant. Defaults to true. */
+    required?: boolean;
+}
 /** Options for `a2aHandler()`. */
 export interface A2aServerOptions {
     /** The card's content: the endpoint `url` is where this handler is mounted. */
@@ -381,6 +488,15 @@ export interface A2aServerOptions {
         protocolVersion?: string;
         tenant?: string;
     }>;
+    /**
+     * Serves several tenants from this one handler, each request routed by the tenant it names: in its
+     * params over JSON-RPC, as its path's first segment over HTTP+JSON (`/{tenant}/message:send`), and in
+     * its message over gRPC. Each tenant's tasks and conversations are its own, and its runs carry the
+     * tenant on their principal, for its credentials and budget. A caller that may not act for the tenant
+     * it names is refused with `A2A_ERRORS.permissionDenied`. `true` takes the defaults. Off by default:
+     * a request's tenant is not read.
+     */
+    tenants?: A2aTenancyOptions | boolean;
 }
 /** The binding a call arrived on. */
 export type A2aBinding = 'JSONRPC' | 'HTTP+JSON' | 'GRPC' | (string & {});
@@ -483,6 +599,11 @@ export interface A2aClientOptions {
      * on `nexus-ai-pro/protocols/a2a/grpc`.
      */
     binding?: 'JSONRPC' | 'HTTP+JSON';
+    /**
+     * The tenant every request names. Defaults to the `tenant` of the interface the card lists for the
+     * binding, as protocol 1.0 requires a client to send it.
+     */
+    tenant?: string;
 }
 /** What to send: text, and optionally data, a conversation, or the paused task it answers. */
 export interface A2aSendOptions {