proofstream_submit_request

Instructions

Implementation Reference

• src/index.ts:33-100 (schema)

  Tool definition and inputSchema for 'proofstream_submit_request'. Defines the tool name, description, and all input parameters (name, email, company, client_type, service, livestream, urgency, description, location, preferred_date, metrics, access_notes, deliverables, billing) with their types, enums, defaults, and required fields.

  const TOOLS: Tool[] = [
    {
      name: 'proofstream_submit_request',
      description: `Submit a human verification request to ProofStream. A real human will go
  on-site with a camera, livestream the verification, and deliver a timestamped
  evidence report (photo + video + written findings). Use this when your workflow
  requires physical confirmation of something in the real world.
  
  Services available:
  - product_verification ($39 standard / $79 with livestream): Authenticate a
    physical product — serial numbers, packaging, labels, authentication markers.
  - document_verification ($99 standard / $149 with livestream): Confirm a physical
    document exists, matches claimed content, photograph stamps/signatures/seals.
  - property_asset_check ($249 standard / $349 with livestream): On-site visual
    condition documentation of a property, vehicle, or asset.
  
  Urgency options: standard (24-72 hours), rush (+50%, within 24h), same_day (+100%)
  
  Returns a case_id you can use to check status. Card is authorized but NOT charged
  until ProofStream accepts the request.`,
      inputSchema: {
        type: 'object',
        required: ['name', 'email', 'service', 'description', 'location'],
        properties: {
          name: { type: 'string', description: 'Requester full name' },
          email: { type: 'string', description: 'Email for report delivery and credentials' },
          company: { type: 'string', description: 'Organization name (optional)' },
          client_type: {
            type: 'string',
            enum: ['AI Agent / Autonomous System', 'Enterprise / Business', 'Individual', 'Legal / Compliance', 'Insurance', 'Other'],
            description: 'Type of requester',
            default: 'AI Agent / Autonomous System'
          },
          service: {
            type: 'string',
            enum: ['product', 'document', 'property'],
            description: 'product = Product Verification | document = Document Verification | property = Property & Asset Check'
          },
          livestream: {
            type: 'string',
            enum: ['yes', 'no'],
            description: 'Whether to include live video feed access (adds cost)',
            default: 'no'
          },
          urgency: {
            type: 'string',
            enum: ['standard', 'rush', 'same_day'],
            description: 'standard = 24-72 hours | rush = within 24h (+50%) | same_day = +100%',
            default: 'standard'
          },
          description: { type: 'string', description: 'What needs to be verified — be specific' },
          location: { type: 'string', description: 'Physical address or location of the item/property to verify' },
          preferred_date: { type: 'string', description: 'Preferred verification date (YYYY-MM-DD)' },
          metrics: { type: 'string', description: 'Specific checkpoints or things to look for during verification' },
          access_notes: { type: 'string', description: 'Access instructions, contact info for site access' },
          deliverables: {
            type: 'array',
            items: { type: 'string', enum: ['Timestamped photo report', 'Full video recording', 'Written verification summary', 'Evidence package with metadata'] },
            description: 'Required deliverables (Timestamped photo report always included)'
          },
          billing: {
            type: 'string',
            enum: ['one_time', 'enterprise'],
            default: 'one_time'
          }
        }
      }
    },

• src/index.ts:132-170 (handler)

  The submitRequest() handler function that executes the tool logic. Builds a payload from args, POSTs it to PROOFSTREAM_API/api/cases, and returns the case_id, quoted_amount, message, next_steps, and status_check info. Handles errors and non-ok responses.

  async function submitRequest(args: Record<string, unknown>): Promise<string> {
    const payload = {
      name: args.name,
      email: args.email,
      company: args.company || '',
      client_type: args.client_type || 'AI Agent / Autonomous System',
      service: args.service,
      livestream: args.livestream || 'no',
      urgency: args.urgency || 'standard',
      description: args.description,
      location: args.location,
      preferred_date: args.preferred_date || '',
      metrics: args.metrics || '',
      access_notes: args.access_notes || '',
      deliverables: args.deliverables || ['Timestamped photo report', 'Written verification summary'],
      billing: args.billing || 'one_time',
    };
  
    const res = await fetch(`${PROOFSTREAM_API}/api/cases`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });
  
    const data = await res.json() as Record<string, unknown>;
  
    if (!res.ok || !data.success) {
      return JSON.stringify({ error: data.error || data.message || 'Submission failed', status: res.status });
    }
  
    return JSON.stringify({
      success: true,
      case_id: data.case_id,
      quoted_amount: data.quoted_amount,
      message: data.message,
      next_steps: 'ProofStream will review your request and respond within a few hours. Payment is authorized but not charged until the request is accepted. You will receive a confirmation email at the address provided.',
      status_check: `Use proofstream_check_status with case_id "${data.case_id}" to track progress.`,
    });
  }

• src/index.ts:243-267 (registration)

  Registration of 'proofstream_submit_request' in the CallToolRequestSchema handler. The switch statement at line 250 routes the tool name 'proofstream_submit_request' to the submitRequest() function. Also includes the ListToolsRequestSchema registration at line 241.

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;
    const toolArgs = (args || {}) as Record<string, unknown>;
  
    try {
      let result: string;
      switch (name) {
        case 'proofstream_submit_request':
          result = await submitRequest(toolArgs);
          break;
        case 'proofstream_check_status':
          result = await checkStatus(toolArgs);
          break;
        case 'proofstream_get_pricing':
          result = getPricing();
          break;
        default:
          throw new Error(`Unknown tool: ${name}`);
      }
      return { content: [{ type: 'text', text: result }] };
    } catch (err) {
      const message = err instanceof Error ? err.message : String(err);
      return { content: [{ type: 'text', text: JSON.stringify({ error: message }) }], isError: true };
    }
  });