Skip to main content
Glama

parse_datetime

Convert any freeform datetime string into ISO 8601, unix epoch, and human-readable relative time, with confidence scoring.

Instructions

Parse any freeform datetime string ('tomorrow at noon', 'yesterday', '2026-05-13T15:30Z', 'in 2 hours') into a fully structured normalized form: ISO 8601, unix epoch, components (year/month/day/hour/min/sec/weekday), relative seconds + human form, confidence score. Saves agent LLM tokens on date parsing. $0.001 USDC.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
inputYesFreeform datetime string.
base_timeNoOptional ISO 8601 reference; defaults to now UTC.
timezoneNoOptional IANA tz name (e.g. 'America/New_York'); defaults to UTC.

Implementation Reference

  • Tool definition and input schema for 'parse_datetime', including description and input properties (input, base_time, timezone).
    {
      name: "parse_datetime",
      description:
        "Parse any freeform datetime string ('tomorrow at noon', 'yesterday', '2026-05-13T15:30Z', 'in 2 hours') into a fully structured normalized form: ISO 8601, unix epoch, components (year/month/day/hour/min/sec/weekday), relative seconds + human form, confidence score. Saves agent LLM tokens on date parsing. $0.001 USDC.",
      inputSchema: {
        type: "object",
        properties: {
          input: { type: "string", description: "Freeform datetime string." },
          base_time: { type: "string", description: "Optional ISO 8601 reference; defaults to now UTC." },
          timezone: { type: "string", description: "Optional IANA tz name (e.g. 'America/New_York'); defaults to UTC." },
        },
        required: ["input"],
      },
    },
  • index.js:68-200 (registration)
    Registration of the parse_datetime tool in the TOOLS array (line 174-187), which is listed via ListToolsRequestSchema handler.
    const TOOLS = [
      {
        name: "anchor_hash",
        description:
          "Anchor a 32-byte hash to BOTH Base mainnet (as EIP-1559 calldata) and Solana mainnet (via the Memo program) in a single call. Returns both transaction hashes plus block-explorer URLs as cryptographic proof of when the hash existed. Pure infrastructure — no opinions about content. Use for DAO vote receipts, AI decision attestations, contract notarization, scientific data integrity, audit trails. $0.005 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            hash: {
              type: "string",
              description: "Pre-computed 32-byte hex hash (64 chars, no 0x prefix). Mutually exclusive with `data`.",
            },
            data: {
              description: "Arbitrary JSON to be canonicalized + SHA-256'd by the server. Mutually exclusive with `hash`.",
            },
            note: {
              type: "string",
              description: "Optional 200-char note included in the response (NOT on-chain).",
            },
          },
        },
      },
      {
        name: "screen_wallet",
        description:
          "Sanctions + AML screening for any EVM or Solana wallet address. Returns sanctions match (boolean), specific OFAC SDN programs flagged (Tornado Cash, Lazarus Group, Hydra Market, Garantex, Blender.io etc.), inferred chain, and a low/medium/high risk verdict. Use for AML pre-flight checks before any treasury transfer, KYC onboarding, vendor diligence, payroll wallet verification, marketplace counterparty checks. $0.001 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            wallet: {
              type: "string",
              description: "EVM 0x… address (40 hex) or Solana base58 pubkey.",
            },
          },
          required: ["wallet"],
        },
      },
      {
        name: "attest_decision",
        description:
          "Verify a wallet signature over (input_hash, output_hash, decision) with domain separation, then dual-chain anchor the resulting Merkle root on Base and Solana mainnet. Returns the verified signer plus on-chain proof URLs. Use when an AI agent's decision needs a cryptographic, auditable receipt — autonomous trade approvals, AI-assisted contract decisions, model-output attestation for liability records. $0.010 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            input_hash: { type: "string", description: "64-char hex SHA-256 of the agent's input." },
            output_hash: { type: "string", description: "64-char hex SHA-256 of the agent's output / decision payload." },
            decision: { type: "string", description: 'Free-form short label, e.g. "APPROVED", "REJECTED", "CONFIDENCE=0.93" (max 64 chars).' },
            scheme: { type: "string", enum: ["eip191", "ed25519"], description: "Signature scheme." },
            signature: { type: "string", description: "0x-prefixed hex (eip191) or base58 (ed25519)." },
            signer_pubkey: { type: "string", description: "Required for ed25519 (Solana base58 pubkey)." },
          },
          required: ["input_hash", "output_hash", "decision", "scheme", "signature"],
        },
      },
      {
        name: "decode_tx",
        description:
          "Structured decode of any mainnet transaction by hash. Supply chain ('base' | 'ethereum' | 'solana') and tx_hash. Returns from/to/value/gas/status/calldata for EVM, or slot/fee/signers/program_calls for Solana. Mined txs cached in-process. Use for tx inspection, audit, agent UX (rendering tx summaries to users). $0.001 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            chain: { type: "string", enum: ["base", "ethereum", "solana"] },
            tx_hash: { type: "string", description: "EVM 0x+64hex or Solana base58 signature." },
          },
          required: ["chain", "tx_hash"],
        },
      },
      {
        name: "resolve_name",
        description:
          "Cross-chain name resolution. Pass a name like 'vitalik.eth' or 'bonfida.sol' and get back the resolved address(es) across supported registries. Currently supports ENS (.eth) and Bonfida SNS (.sol). Cached 1h server-side. $0.001 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            name: { type: "string", description: "Human-readable name, e.g. 'vitalik.eth' or 'bonfida.sol'." },
          },
          required: ["name"],
        },
      },
      {
        name: "token_price",
        description:
          "USD spot price for any major token. Pass either `symbol` (BTC, ETH, SOL, USDC, etc.) OR (chain + contract). Returns USD price, 24h change percent, market cap, fetched-at timestamp. CoinGecko-backed, cached 60s. $0.001 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            symbol: { type: "string", description: "Token symbol like 'ETH'. Mutually exclusive with chain+contract." },
            chain: { type: "string", description: "Chain slug: base, ethereum, solana, polygon, arbitrum, optimism, bsc, avalanche." },
            contract: { type: "string", description: "Token contract address. Required with chain." },
          },
        },
      },
      {
        name: "decode_calldata",
        description:
          "Decode raw EVM calldata into a human-readable function name, canonical signature, and typed parameter values. Resolves the 4-byte selector against openchain.xyz's signature directory, then ABI-decodes the args. Use for tx inspection before signing, mempool analysis, debug. EVM-only (chain='ethereum'); 'solana' returns 400. $0.001 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            chain: { type: "string", enum: ["ethereum", "solana"], description: "EVM-only; 'solana' returns 400." },
            calldata_hex: { type: "string", description: "Raw EVM calldata (>=4 byte selector), with or without 0x prefix." },
            contract_address: { type: "string", description: "Optional. Reserved for future on-chain ABI lookups." },
          },
          required: ["chain", "calldata_hex"],
        },
      },
      {
        name: "parse_datetime",
        description:
          "Parse any freeform datetime string ('tomorrow at noon', 'yesterday', '2026-05-13T15:30Z', 'in 2 hours') into a fully structured normalized form: ISO 8601, unix epoch, components (year/month/day/hour/min/sec/weekday), relative seconds + human form, confidence score. Saves agent LLM tokens on date parsing. $0.001 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            input: { type: "string", description: "Freeform datetime string." },
            base_time: { type: "string", description: "Optional ISO 8601 reference; defaults to now UTC." },
            timezone: { type: "string", description: "Optional IANA tz name (e.g. 'America/New_York'); defaults to UTC." },
          },
          required: ["input"],
        },
      },
      {
        name: "intel_wallet",
        description:
          "Unified wallet intelligence bundle. ONE call returns balances on Base + Ethereum + Solana, USDC across chains, transaction count, ENS/SNS reverse lookup, and sanctions verdict — all aggregated from 8–10 parallel free public sources. Replaces a wallet-investigation script with a single $0.005 call. Use for KYB pre-flight, counterparty research, fraud detection. $0.005 USDC.",
        inputSchema: {
          type: "object",
          properties: {
            wallet: { type: "string", description: "EVM 0x… address (40 hex) or Solana base58 pubkey." },
          },
          required: ["wallet"],
        },
      },
    ];
  • Handler for 'parse_datetime' in the buildRequest switch-case: builds a POST request to BASE_URL/v1/parse/datetime with the input, optional base_time, and timezone parameters. The actual parsing logic is delegated to the remote API endpoint.
    case "parse_datetime":
      return {
        url: `${BASE_URL}/v1/parse/datetime`,
        opts: {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            input: String(args.input).slice(0, 500),
            ...(args.base_time ? { base_time: args.base_time } : {}),
            ...(args.timezone ? { timezone: args.timezone } : {}),
          }),
        },
      };
Behavior4/5

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

With no annotations, the description carries the full burden. It discloses cost ($0.001 USDC) and explains the output structure (ISO 8601, unix epoch, components, confidence). It does not mention error handling or limits, but overall provides good behavioral context.

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 that includes examples, output list, and cost info. It is concise but somewhat dense; slight improvement could come from breaking into bullet points or shorter sentences.

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

Completeness4/5

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

Given no output schema, the description thoroughly explains the return format (ISO 8601, unix epoch, components, confidence). It also adds context on pricing. However, it does not cover error cases or rate limits, leaving minor gaps.

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

Parameters4/5

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

Schema coverage is 100%, so the description does not need to repeat parameter definitions. It adds value by providing example inputs ('tomorrow at noon') and stating the default behavior for optional parameters, going beyond the schema's minimal descriptions.

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 uses specific verbs ('Parse') and resource ('freeform datetime string') and lists detailed output components. It clearly distinguishes itself from siblings like anchor_hash or decode_calldata which serve entirely different purposes.

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 includes a clear usage hint ('Saves agent LLM tokens on date parsing') implying efficiency is a reason to use this tool. However, it does not explicitly state when not to use it or mention alternatives.

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/hypeprinter007-stack/anchor-x402-mcp'

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