Skip to main content
Glama

generate_usage_agreement

Generate a usage agreement for approved PixelVault assets after human shortlist approval. Provide asset IDs, project details, and license type to auto-create the document.

Instructions

Generate a usage agreement document for approved PixelVault assets. Call after human approval of a shortlist.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
asset_idsYesApproved asset IDs.
project_titleYesProduction or project title.
production_companyYesProduction company name.
distribution_platformYesDistribution platforms (e.g. Netflix, Broadcast).
territoryYesDistribution territory.
air_dateNoAnticipated air date (YYYY-MM-DD).
license_typeYesLicense type.

Implementation Reference

  • The handler function that executes the generate_usage_agreement tool logic. It generates a usage agreement document as a formatted text string using the provided arguments (asset_ids, project_title, production_company, etc.).
    async function handleGenerateUsageAgreement(args) {
      const { asset_ids, project_title, production_company, distribution_platform, territory, air_date, license_type } = args;
      const today = new Date().toISOString().split('T')[0];
      const agreementId = `PV-${Date.now().toString(36).toUpperCase()}`;
      const text = [
        `PIXELVAULT USAGE AGREEMENT`,
        `Agreement ID: ${agreementId} | Generated: ${today} | Status: DRAFT`,
        ``,
        `Production Company: ${production_company}`,
        `Project: ${project_title}`,
        `License: ${license_type} | Platform: ${distribution_platform} | Territory: ${territory}`,
        air_date ? `Air Date: ${air_date}` : null,
        ``,
        `Approved Assets (${asset_ids.length}):`,
        ...asset_ids.map((id, i) => `  ${i + 1}. Asset ID: ${id}`),
        ``,
        `All assets sourced from licensed AI platforms (Adobe Firefly, Moonvalley).`,
        `Complete payment and execute at: ${SITE_URL}`,
        `Questions: outreach@pixelvaultai.com`,
      ].filter(l => l !== null).join('\n');
      return { content: [{ type: 'text', text }] };
    }
  • The tool registration definition with input schema for generate_usage_agreement. Defines required parameters: asset_ids (array of strings), project_title, production_company, distribution_platform, territory, license_type, and optional air_date.
    {
      name: 'generate_usage_agreement',
      description: 'Generate a usage agreement document for approved PixelVault assets. Call after human approval of a shortlist.',
      inputSchema: {
        type: 'object',
        properties: {
          asset_ids: { type: 'array', items: { type: 'string' }, description: 'Approved asset IDs.' },
          project_title: { type: 'string', description: 'Production or project title.' },
          production_company: { type: 'string', description: 'Production company name.' },
          distribution_platform: { type: 'string', description: 'Distribution platforms (e.g. Netflix, Broadcast).' },
          territory: { type: 'string', description: 'Distribution territory.' },
          air_date: { type: 'string', description: 'Anticipated air date (YYYY-MM-DD).' },
          license_type: { type: 'string', enum: ['Film & TV Commercial', 'Editorial', 'Commercial Digital'], description: 'License type.' },
        },
        required: ['asset_ids', 'project_title', 'production_company', 'distribution_platform', 'territory', 'license_type'],
      },
    },
  • src/index.js:180-186 (registration)
    The registration of the tool handler in the CallToolRequestSchema switch-case. Maps the tool name 'generate_usage_agreement' to its handler function handleGenerateUsageAgreement.
    server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;
      try {
        switch (name) {
          case 'search_assets': return await handleSearchAssets(args);
          case 'get_asset_details': return await handleGetAssetDetails(args);
          case 'generate_usage_agreement': return await handleGenerateUsageAgreement(args);
  • src/index.js:54-98 (registration)
    The tool list where generate_usage_agreement is registered within the TOOLS array that's returned by ListToolsRequestSchema.
    const TOOLS = [
      {
        name: 'search_assets',
        description: 'Search PixelVault for pre-cleared, commercially licensed AI-generated assets matched to a creative brief. Every asset is sourced from licensed AI platforms (Adobe Firefly, Moonvalley) and carries a compliance-cleared status. Returns a ranked shortlist with compliance status, format, platform, and rationale.',
        inputSchema: {
          type: 'object',
          properties: {
            brief: { type: 'string', description: 'Natural language description of the visual asset needed.' },
            license_type: { type: 'string', enum: ['Film & TV', 'Editorial', 'Commercial'], description: 'License type required. Auto-detected from brief if omitted.' },
            format: { type: 'string', enum: ['video', 'image'], description: 'Asset format filter.' },
            vertical: { type: 'string', description: 'Vertical: post production, editorial, or ecommerce.' },
            territory: { type: 'string', description: 'Distribution territory (e.g. Worldwide, US Only).' },
          },
          required: ['brief'],
        },
      },
      {
        name: 'get_asset_details',
        description: 'Get full metadata and compliance documentation for a specific PixelVault asset by ID.',
        inputSchema: {
          type: 'object',
          properties: {
            asset_id: { type: 'string', description: 'The asset ID returned by search_assets.' },
          },
          required: ['asset_id'],
        },
      },
      {
        name: 'generate_usage_agreement',
        description: 'Generate a usage agreement document for approved PixelVault assets. Call after human approval of a shortlist.',
        inputSchema: {
          type: 'object',
          properties: {
            asset_ids: { type: 'array', items: { type: 'string' }, description: 'Approved asset IDs.' },
            project_title: { type: 'string', description: 'Production or project title.' },
            production_company: { type: 'string', description: 'Production company name.' },
            distribution_platform: { type: 'string', description: 'Distribution platforms (e.g. Netflix, Broadcast).' },
            territory: { type: 'string', description: 'Distribution territory.' },
            air_date: { type: 'string', description: 'Anticipated air date (YYYY-MM-DD).' },
            license_type: { type: 'string', enum: ['Film & TV Commercial', 'Editorial', 'Commercial Digital'], description: 'License type.' },
          },
          required: ['asset_ids', 'project_title', 'production_company', 'distribution_platform', 'territory', 'license_type'],
        },
      },
    ];
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It does not disclose any behavioral traits beyond generation, such as side effects, idempotency, or output format. This is a significant gap for a mutation-like tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence plus a usage hint, which is concise and front-loaded. However, it could be slightly more structured to include expected output, but overall it's efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a generation tool with 7 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the output, success/failure indicators, or any prerequisites beyond 'approved' assets.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema describes all 7 parameters with coverage of 100%, so the schema carries the meaning. The description adds no additional semantic value beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'generate', the resource 'usage agreement document', and the context 'for approved PixelVault assets'. It distinguishes well from sibling tools (get_asset_details, search_assets) which focus on retrieval.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit when-to-use: 'Call after human approval of a shortlist.' It provides clear context but does not explicitly mention when not to use or alternatives, though siblings are clearly different.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/rsweeting1/pixelvault-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server