@noodleseed/one 0.149.0 → 0.151.0

package/node_modules/@noodle-borg/service/dist/invocation-context.js

@@ -1,56 +1,4 @@
-import { resolveInvocationContext, toolTouchesDelegatedAuth, } from '@noodle-borg/assistant-gateway/portable';
-import { executeAmbientContext, } from '@noodle-borg/runtime';
-/** Resolve one immutable snapshot, including a schema-validated read-only ambient provider. */
-export async function resolveInvocationContextSnapshot(input) {
-    const callerPreference = {
-        ...(input.caller?.locale ? { locale: input.caller.locale } : {}),
-        ...(input.caller?.timeZone ? { timeZone: input.caller.timeZone } : {}),
-        ...(input.applicationPreference ?? {}),
-    };
-    const clientHint = {
-        ...(input.clientLocationHint?.timeZone === undefined
-            ? {}
-            : { timeZone: input.clientLocationHint.timeZone }),
-        ...(input.clientHint ?? {}),
-    };
-    const temporal = resolveInvocationContext({
-        instant: input.instant,
-        ...(Object.keys(callerPreference).length > 0
-            ? { applicationPreference: callerPreference }
-            : {}),
-        ...(Object.keys(clientHint).length === 0 ? {} : { clientHint }),
-        ...(input.artifact.server.context?.defaults
-            ? { defaults: input.artifact.server.context.defaults }
-            : {}),
-    });
-    const context = {
-        ...temporal,
-        ...(input.clientLocationHint === undefined
-            ? {}
-            : { location: { ...input.clientLocationHint, source: 'client-hint' } }),
-    };
-    const ambient = input.artifact.server.context?.ambient;
-    if (!ambient)
-        return context;
-    // An anonymous principal can never satisfy a delegated-auth fulfilment: the broker exchange
-    // is guaranteed to fail, so skip the doomed round trip instead of paying it every turn.
-    if (input.caller?.identityKind === 'anonymous') {
-        const delegatedKeys = input.executeDeps.broker.assistantDelegatedAuthKeys?.();
-        if (delegatedKeys !== undefined &&
-            delegatedKeys.size > 0 &&
-            toolTouchesDelegatedAuth(ambient, delegatedKeys)) {
-            return { ...context, ambientStatus: 'unavailable' };
-        }
-    }
-    const result = await executeAmbientContext(input.artifact, {
-        ...input.executeDeps,
-        ...(input.caller ? { caller: input.caller } : {}),
-        context,
-    });
-    if (!result.ok)
-        return { ...context, ambientStatus: 'unavailable' };
-    return { ...context, ambientStatus: 'available', ambient: result.output };
-}
+import { resolveInvocationContextSnapshot } from '@noodle-borg/assistant-gateway/portable';
 /** Bind the shared snapshot resolver to stateless MCP requests without coupling it to router code. */
 export function createMcpInvocationContextResolver(clock = () => new Date()) {
     return ({ target, caller, clientHint }) => resolveInvocationContextSnapshot({

package/node_modules/@noodle-borg/service/dist/routes/assistant-interaction-resolution.js

@@ -1,5 +1,4 @@
-import { withAssistantSessionExecutionAuthority } from '@noodle-borg/assistant-gateway/portable';
-import { resolveInvocationContextSnapshot } from '../invocation-context.js';
+import { resolveInvocationContextSnapshot, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { now } from './assistant.js';
 export function assistantInteractionScope(id, session, instant) {
     return {

package/node_modules/@noodle-borg/service/dist/routes/assistant-public-configuration.js

@@ -29,7 +29,7 @@ export async function handlePublicAssistantConfiguration(req, res, embedId, deps
     if (target === undefined) {
         return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
     }
-    const resolved = await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(authorized.embed), deps.appearance);
+    const resolved = await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(authorized.embed), deps.appearance, 'public');
     applyBrowserCors(req, res, origin);
     res.setHeader('cache-control', 'private, no-cache');
     return sendJson(res, 200, {

package/node_modules/@noodle-borg/service/dist/routes/assistant-public-session.js

@@ -59,7 +59,7 @@ export async function handlePublicAssistantSession(req, res, deps) {
             if (!target?.deploymentId)
                 throw new Error('assistant deployment vanished mid-mint');
             const current = now(deps);
-            configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(input.embed), deps.appearance)).effective;
+            configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(input.embed), deps.appearance, 'public')).effective;
             const created = await deps.store.createSession({
                 // A public surface has no client credential, so the embed id stands in as the minting
                 // authority. It is not a secret and nothing downstream may begin treating it as one.

package/node_modules/@noodle-borg/service/dist/routes/assistant-suggestions.js

@@ -1,8 +1,7 @@
 import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
-import { parseAssistantContextPreferences, surfaceEnvelope, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { parseAssistantContextPreferences, resolveInvocationContextSnapshot, surfaceEnvelope, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { assistantSuggestionsRequestSchema } from '@noodle-borg/wire-contracts';
 import { readJsonBody, sendJson } from '../http-util.js';
-import { resolveInvocationContextSnapshot } from '../invocation-context.js';
 import { generateInitialAssistantSuggestions } from './assistant-agent.js';
 import { applyBrowserCors, authenticateSession, now } from './assistant-route-http.js';
 import { sessionScopedTarget } from './assistant-session-target.js';

package/node_modules/@noodle-borg/service/dist/routes/assistant.js

@@ -1,15 +1,13 @@
 import { clientAddressBucket, } from '@noodle-borg/admission-limits/portable';
 import { assistantModelFailure, assistantModelSource, assistantModelTransport, } from '@noodle-borg/assistant-gateway/model-runtime';
-import { ASSISTANT_SESSION_IDLE_MS, dispatchAssistantTool, effectiveAssistantBrowserConfiguration, isAssistantPageContext, isAssistantVerifiedClaims, parseAssistantContextPreferences, parseAssistantCustomerRouting, refuseBridgeToolCall, refusePublicTurn, resumeTurnMessage, resumeUnavailableMessage, shouldAutoResume, surfaceBindingForOrigin, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { ASSISTANT_SESSION_IDLE_MS, effectiveAssistantBrowserConfiguration, executeAssistantAppToolCall, isAssistantPageContext, isAssistantVerifiedClaims, parseAssistantContextPreferences, parseAssistantCustomerRouting, refuseBridgeToolCall, refusePublicTurn, resolveInvocationContextSnapshot, resumeTurnMessage, resumeUnavailableMessage, shouldAutoResume, surfaceBindingForOrigin, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { canonicalizeAuthorizationClaimValues } from '@noodle-borg/auth';
-import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
 import { tenantMcpUrl } from '@noodle-borg/module';
-import { assistantRefusedTurnUsageRequestEvent, assistantSessionUsageRequestEvent, assistantTurnNumber, assistantTurnUsageRequestEvent, captureAssistantUsage, } from '@noodle-borg/observability';
-import { evaluateToolAuthorization, mapExecutionError, mapResourceContents, mapResourcesList, mapToolOutput, mapToolsList, } from '@noodle-borg/protocol';
+import { assistantAppToolCallRecorder, assistantRefusedTurnUsageRequestEvent, assistantSessionUsageRequestEvent, assistantTurnNumber, assistantTurnUsageRequestEvent, captureAssistantUsage, } from '@noodle-borg/observability';
+import { mapExecutionError, mapResourceContents, mapResourcesList, mapToolOutput, mapToolsList, } from '@noodle-borg/protocol';
 import { executeResource } from '@noodle-borg/runtime';
 import { assistantMessageTurnRequestSchema, assistantResumeTurnRequestSchema, assistantSessionResponseSchema, } from '@noodle-borg/wire-contracts';
 import { readJsonBody, sendForbidden, sendJson, sendUnauthorized } from '../http-util.js';
-import { resolveInvocationContextSnapshot } from '../invocation-context.js';
 import { createAssistantTurnStats, runAgentTurn } from './assistant-agent.js';
 import { elevateAssistantSession } from './assistant-elevation.js';
 import { executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, resolveAssistantKnowledge, } from './assistant-knowledge.js';
@@ -99,7 +97,7 @@ export async function handleAssistantSession(req, res, deps) {
     const declaredClaims = assistant.sessionClaims ?? {};
     const claims = Object.fromEntries(Object.entries(isAssistantVerifiedClaims(parsed.claims) ? parsed.claims : {}).filter(([key]) => key in declaredClaims));
     const current = now(deps);
-    const configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, client.tenant, deps.appearance)).effective;
+    const configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, client.tenant, deps.appearance, surfaceBinding.kind === 'pre-surfaces' ? undefined : surfaceBinding.kind)).effective;
     const roles = canonicalizeAuthorizationClaimValues(parsed.user.roles, 'role');
     const scopes = canonicalizeAuthorizationClaimValues(parsed.user.scopes, 'scope');
     // Hoisted so an elevation and a fresh exchange bind the *same* principal. Two constructions would be
@@ -387,9 +385,21 @@ export async function handleAssistantAppRequest(req, res, deps) {
     // Answered before any resolution work, so a refused browser agent costs nothing (ADR 0220). The
     // marker is client-declared: it selects a budget, never authority, which the session below decides.
     const bridged = method === 'tools/call' && body.value.bridge === 'webmcp';
+    // Bound before the budget gate below, because that refusal is the one an operator watching a
+    // browser agent most needs to see, and answering it before any resolution work must not mean
+    // answering it silently. `bridged` is attribution only: it labels the row, never authority.
+    const record = assistantAppToolCallRecorder({
+        capture: deps.captureRequestEvent,
+        session,
+        ...(typeof params.name === 'string' ? { toolName: params.name } : { toolName: undefined }),
+        bridged,
+        clock: () => performance.now(),
+    });
     const refusal = bridged ? await refuseBridgeToolCall(deps, session) : undefined;
-    if (refusal)
+    if (refusal) {
+        record('refused', refusal.code);
         return sendJson(res, refusal.status, { error: refusal.message, code: refusal.code });
+    }
     const knowledge = await resolveAssistantKnowledge(target.served);
     if (method === 'tools/list') {
         return sendJson(res, 200, mapToolsList(target.served.artifact, session.caller, {
@@ -405,15 +415,18 @@ export async function handleAssistantAppRequest(req, res, deps) {
         const resource = target.served.artifact.resources?.find((candidate) => candidate.uri === params.uri);
         if (!resource)
             return sendJson(res, 404, { error: 'resource not found' });
+        // One projection for both the snapshot and the execution: they must agree, and building it
+        // twice was two chances for them not to.
+        const executeDeps = withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session);
         const context = await resolveInvocationContextSnapshot({
             artifact: target.served.artifact,
-            executeDeps: withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
+            executeDeps,
             caller: session.caller,
             instant: now(deps),
             ...(session.preferences ? { applicationPreference: session.preferences } : {}),
         });
         const execution = await executeResource(target.served.artifact, resource.name, {}, {
-            ...withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
+            ...executeDeps,
             caller: session.caller,
             context,
         });
@@ -422,58 +435,64 @@ export async function handleAssistantAppRequest(req, res, deps) {
         return sendJson(res, 200, mapResourceContents(resource.uri, resource.mimeType, execution.output, resource._meta));
     }
     if (method === 'tools/call') {
-        if (typeof params.name !== 'string')
+        if (typeof params.name !== 'string') {
+            record('refused', 'tool_name_required');
             return sendJson(res, 400, { error: 'tool name required' });
-        const knowledgeComponent = findAssistantKnowledgeComponent(knowledge, params.name);
+        }
+        const toolName = params.name;
+        const knowledgeComponent = findAssistantKnowledgeComponent(knowledge, toolName);
         if (knowledge !== undefined && knowledgeComponent !== undefined) {
             const content = await executeAssistantKnowledgeSearch(knowledge, knowledgeComponent, params.arguments ?? {});
-            return sendJson(res, 200, mapToolOutput(JSON.parse(content)));
+            // A knowledge search reports failure in its payload rather than by throwing, so reading the
+            // envelope is the only way not to file a refused or failed search as a successful one.
+            const payload = JSON.parse(content);
+            const failure = isRecord(payload) && typeof payload.error === 'string' ? payload.error : undefined;
+            if (failure === undefined)
+                record('ok');
+            else
+                record(failure === 'invalid_arguments' ? 'refused' : 'failed', failure);
+            return sendJson(res, 200, mapToolOutput(payload));
         }
-        const tool = target.served.artifact.tools.find((candidate) => candidate.name === params.name);
-        if (!tool || tool._meta?.ui?.visibility?.includes('app') === false) {
+        const call = await executeAssistantAppToolCall({
+            artifact: target.served.artifact,
+            deps: target.served.deps,
+            session,
+            toolName,
+            arguments: params.arguments,
+            now: () => now(deps),
+            store: deps.store,
+            audit: deps.audit,
+        });
+        if (call.kind === 'not-found') {
+            record('refused', 'app_tool_not_found');
             return sendJson(res, 404, { error: 'app tool not found' });
         }
-        if (!evaluateToolAuthorization(tool.authorization, session.caller).allow) {
+        if (call.kind === 'forbidden') {
+            record('refused', 'tool_forbidden');
             return sendJson(res, 403, { error: 'tool forbidden' });
         }
-        const context = await resolveInvocationContextSnapshot({
-            artifact: target.served.artifact,
-            executeDeps: withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
-            caller: session.caller,
-            instant: now(deps),
-            ...(session.preferences ? { applicationPreference: session.preferences } : {}),
-        });
-        const validated = validateJsonSchemaWithDefaults(tool.inputSchema, params.arguments ?? {});
-        if (validated.issues.length > 0) {
+        if (call.kind === 'invalid-arguments') {
+            record('refused', 'invalid_tool_arguments');
             return sendJson(res, 200, {
                 content: [{ type: 'text', text: 'invalid tool arguments' }],
                 isError: true,
             });
         }
-        const dispatched = await dispatchAssistantTool({
-            artifact: target.served.artifact,
-            tool,
-            arguments: validated.value,
-            executeDeps: withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
-            caller: session.caller,
-            context,
-            session,
-            store: deps.store,
-            audit: deps.audit,
-            now: () => now(deps),
-        });
-        if (dispatched.kind === 'event') {
-            if (dispatched.event === 'tool_proposed' || dispatched.event === 'input_requested') {
-                return sendJson(res, 200, {
-                    interaction: { event: dispatched.event, data: dispatched.data },
-                });
-            }
+        if (call.kind === 'interaction') {
+            // A raised confirmation is not a failure and not yet an execution: the bridge did what it
+            // should, and the interaction is answered on its own route.
+            record('ok');
+            return sendJson(res, 200, { interaction: { event: call.event, data: call.data } });
+        }
+        if (call.kind === 'error') {
+            record('failed', call.code);
             return sendJson(res, 200, {
-                content: [{ type: 'text', text: String(dispatched.data.code ?? dispatched.event) }],
+                content: [{ type: 'text', text: call.code }],
                 isError: true,
             });
         }
-        return sendJson(res, 200, mapToolOutput(dispatched.output));
+        record('ok');
+        return sendJson(res, 200, mapToolOutput(call.output));
     }
     return sendJson(res, 400, { error: 'unsupported MCP App method' });
 }

package/node_modules/@noodle-borg/service/package.json

@@ -39,7 +39,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.88.0",
+    "@noodle-borg/agent-kit": "0.90.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

package/node_modules/@noodle-borg/wire-contracts/dist/index.d.ts

@@ -18,6 +18,7 @@ export * from './deployment-package.js';
 export * from './distribution.js';
 export * from './feedback.js';
 export * from './knowledge.js';
+export * from './managed-assistant-sponsorship.js';
 export * from './platform-account-reset.js';
 export * from './platform-auth.js';
 /** Informational origin of a deployment; never an authorization or policy input. */

package/node_modules/@noodle-borg/wire-contracts/dist/index.js

@@ -20,6 +20,7 @@ export * from './deployment-package.js';
 export * from './distribution.js';
 export * from './feedback.js';
 export * from './knowledge.js';
+export * from './managed-assistant-sponsorship.js';
 export * from './platform-account-reset.js';
 export * from './platform-auth.js';
 // ─── Deploy ─────────────────────────────────────────────────────────────────────

package/node_modules/@noodle-borg/wire-contracts/dist/managed-assistant-sponsorship.d.ts

@@ -0,0 +1,297 @@
+import { z } from 'zod';
+export declare const MANAGED_ASSISTANT_SPONSORSHIP_MAX_GRANT_TURNS_PER_DAY = 100000;
+export declare const ManagedAssistantSponsorshipGrantCreateRequestSchema: z.ZodObject<{
+    additionalTurnsPerDay: z.ZodNumber;
+    startsAt: z.ZodOptional<z.ZodISODateTime>;
+    expiresAt: z.ZodISODateTime;
+    reason: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type ManagedAssistantSponsorshipGrantCreateRequest = z.infer<typeof ManagedAssistantSponsorshipGrantCreateRequestSchema>;
+export declare const ManagedAssistantSponsorshipGrantRevokeRequestSchema: z.ZodObject<{
+    reason: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type ManagedAssistantSponsorshipGrantRevokeRequest = z.infer<typeof ManagedAssistantSponsorshipGrantRevokeRequestSchema>;
+export declare const ManagedAssistantSponsorshipGrantSchema: z.ZodObject<{
+    id: z.ZodString;
+    billingAccountId: z.ZodString;
+    additionalTurnsPerDay: z.ZodNumber;
+    startsAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    reason: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        revoked: "revoked";
+        scheduled: "scheduled";
+        expired: "expired";
+    }>;
+    createdAt: z.ZodISODateTime;
+    revokedAt: z.ZodOptional<z.ZodISODateTime>;
+    revocationReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ManagedAssistantSponsorshipGrant = z.infer<typeof ManagedAssistantSponsorshipGrantSchema>;
+export declare const ManagedAssistantSponsorshipResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        billingAccountId: z.ZodString;
+        mode: z.ZodLiteral<"sponsored_beta">;
+        defaultTurnsPerDay: z.ZodNumber;
+        bonusTurnsPerDay: z.ZodNumber;
+        totalTurnsPerDay: z.ZodNumber;
+        spend: z.ZodObject<{
+            state: z.ZodEnum<{
+                normal: "normal";
+                approaching: "approaching";
+                near: "near";
+                limited: "limited";
+                closed: "closed";
+            }>;
+            allowanceUnits: z.ZodNumber;
+            usedUnitsToday: z.ZodNumber;
+            turnsRemaining: z.ZodNumber;
+        }, z.core.$strict>;
+        resetAt: z.ZodISODateTime;
+        grants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            billingAccountId: z.ZodString;
+            additionalTurnsPerDay: z.ZodNumber;
+            startsAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+            reason: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                revoked: "revoked";
+                scheduled: "scheduled";
+                expired: "expired";
+            }>;
+            createdAt: z.ZodISODateTime;
+            revokedAt: z.ZodOptional<z.ZodISODateTime>;
+            revocationReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        platform: z.ZodOptional<z.ZodObject<{
+            globalTurnsPerDay: z.ZodNumber;
+            spend: z.ZodObject<{
+                state: z.ZodEnum<{
+                    normal: "normal";
+                    approaching: "approaching";
+                    near: "near";
+                    limited: "limited";
+                    closed: "closed";
+                }>;
+                allowanceUnits: z.ZodNumber;
+                usedUnitsToday: z.ZodNumber;
+                turnsRemaining: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ManagedAssistantSponsorshipResponse = z.infer<typeof ManagedAssistantSponsorshipResponseSchema>;
+/** Client reader strips additive fields at every layer while the service output stays strict. */
+export declare const ManagedAssistantSponsorshipClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        spend: z.ZodObject<{
+            state: z.ZodEnum<{
+                normal: "normal";
+                approaching: "approaching";
+                near: "near";
+                limited: "limited";
+                closed: "closed";
+            }>;
+            allowanceUnits: z.ZodNumber;
+            usedUnitsToday: z.ZodNumber;
+            turnsRemaining: z.ZodNumber;
+        }, z.core.$strip>;
+        grants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            billingAccountId: z.ZodString;
+            additionalTurnsPerDay: z.ZodNumber;
+            startsAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+            reason: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                revoked: "revoked";
+                scheduled: "scheduled";
+                expired: "expired";
+            }>;
+            createdAt: z.ZodISODateTime;
+            revokedAt: z.ZodOptional<z.ZodISODateTime>;
+            revocationReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        platform: z.ZodOptional<z.ZodObject<{
+            globalTurnsPerDay: z.ZodNumber;
+            spend: z.ZodObject<{
+                state: z.ZodEnum<{
+                    normal: "normal";
+                    approaching: "approaching";
+                    near: "near";
+                    limited: "limited";
+                    closed: "closed";
+                }>;
+                allowanceUnits: z.ZodNumber;
+                usedUnitsToday: z.ZodNumber;
+                turnsRemaining: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        billingAccountId: z.ZodString;
+        mode: z.ZodLiteral<"sponsored_beta">;
+        defaultTurnsPerDay: z.ZodNumber;
+        bonusTurnsPerDay: z.ZodNumber;
+        totalTurnsPerDay: z.ZodNumber;
+        resetAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ManagedAssistantSponsorshipGrantMutationResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        replayed: z.ZodBoolean;
+        grant: z.ZodObject<{
+            id: z.ZodString;
+            billingAccountId: z.ZodString;
+            additionalTurnsPerDay: z.ZodNumber;
+            startsAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+            reason: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                revoked: "revoked";
+                scheduled: "scheduled";
+                expired: "expired";
+            }>;
+            createdAt: z.ZodISODateTime;
+            revokedAt: z.ZodOptional<z.ZodISODateTime>;
+            revocationReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        sponsorship: z.ZodObject<{
+            billingAccountId: z.ZodString;
+            mode: z.ZodLiteral<"sponsored_beta">;
+            defaultTurnsPerDay: z.ZodNumber;
+            bonusTurnsPerDay: z.ZodNumber;
+            totalTurnsPerDay: z.ZodNumber;
+            spend: z.ZodObject<{
+                state: z.ZodEnum<{
+                    normal: "normal";
+                    approaching: "approaching";
+                    near: "near";
+                    limited: "limited";
+                    closed: "closed";
+                }>;
+                allowanceUnits: z.ZodNumber;
+                usedUnitsToday: z.ZodNumber;
+                turnsRemaining: z.ZodNumber;
+            }, z.core.$strict>;
+            resetAt: z.ZodISODateTime;
+            grants: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                billingAccountId: z.ZodString;
+                additionalTurnsPerDay: z.ZodNumber;
+                startsAt: z.ZodISODateTime;
+                expiresAt: z.ZodISODateTime;
+                reason: z.ZodString;
+                status: z.ZodEnum<{
+                    active: "active";
+                    revoked: "revoked";
+                    scheduled: "scheduled";
+                    expired: "expired";
+                }>;
+                createdAt: z.ZodISODateTime;
+                revokedAt: z.ZodOptional<z.ZodISODateTime>;
+                revocationReason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            platform: z.ZodOptional<z.ZodObject<{
+                globalTurnsPerDay: z.ZodNumber;
+                spend: z.ZodObject<{
+                    state: z.ZodEnum<{
+                        normal: "normal";
+                        approaching: "approaching";
+                        near: "near";
+                        limited: "limited";
+                        closed: "closed";
+                    }>;
+                    allowanceUnits: z.ZodNumber;
+                    usedUnitsToday: z.ZodNumber;
+                    turnsRemaining: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ManagedAssistantSponsorshipGrantMutationResponse = z.infer<typeof ManagedAssistantSponsorshipGrantMutationResponseSchema>;
+export declare const ManagedAssistantSponsorshipGrantMutationClientResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        replayed: z.ZodBoolean;
+        grant: z.ZodObject<{
+            id: z.ZodString;
+            billingAccountId: z.ZodString;
+            additionalTurnsPerDay: z.ZodNumber;
+            startsAt: z.ZodISODateTime;
+            expiresAt: z.ZodISODateTime;
+            reason: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                revoked: "revoked";
+                scheduled: "scheduled";
+                expired: "expired";
+            }>;
+            createdAt: z.ZodISODateTime;
+            revokedAt: z.ZodOptional<z.ZodISODateTime>;
+            revocationReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        sponsorship: z.ZodObject<{
+            spend: z.ZodObject<{
+                state: z.ZodEnum<{
+                    normal: "normal";
+                    approaching: "approaching";
+                    near: "near";
+                    limited: "limited";
+                    closed: "closed";
+                }>;
+                allowanceUnits: z.ZodNumber;
+                usedUnitsToday: z.ZodNumber;
+                turnsRemaining: z.ZodNumber;
+            }, z.core.$strip>;
+            grants: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                billingAccountId: z.ZodString;
+                additionalTurnsPerDay: z.ZodNumber;
+                startsAt: z.ZodISODateTime;
+                expiresAt: z.ZodISODateTime;
+                reason: z.ZodString;
+                status: z.ZodEnum<{
+                    active: "active";
+                    revoked: "revoked";
+                    scheduled: "scheduled";
+                    expired: "expired";
+                }>;
+                createdAt: z.ZodISODateTime;
+                revokedAt: z.ZodOptional<z.ZodISODateTime>;
+                revocationReason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            platform: z.ZodOptional<z.ZodObject<{
+                globalTurnsPerDay: z.ZodNumber;
+                spend: z.ZodObject<{
+                    state: z.ZodEnum<{
+                        normal: "normal";
+                        approaching: "approaching";
+                        near: "near";
+                        limited: "limited";
+                        closed: "closed";
+                    }>;
+                    allowanceUnits: z.ZodNumber;
+                    usedUnitsToday: z.ZodNumber;
+                    turnsRemaining: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            billingAccountId: z.ZodString;
+            mode: z.ZodLiteral<"sponsored_beta">;
+            defaultTurnsPerDay: z.ZodNumber;
+            bonusTurnsPerDay: z.ZodNumber;
+            totalTurnsPerDay: z.ZodNumber;
+            resetAt: z.ZodISODateTime;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=managed-assistant-sponsorship.d.ts.map