list_sip_accounts

Instructions

{
    "sipaccounts": [
        {
            "id": 61,
            "name": "12345",
            "callerid": "17254999999",
            "label": "TEST DEVICE",
            "host": "dynamic",
            "charge": "0.0",
            "talk_time": 0,
            "rewrite_enabled": false,
            "rewrite_cond": "8",
            "rewrite_prefix": "7",
            "didinfo_enabled": false,
            "ip_restrict": false,
            "call_restrict": true,
            "call_limit": 2800,
            "channels_restrict": false,
            "max_channels": 1,
            "cost_limit": false,
            "max_call_cost": "5.0",
            "created_at": "2024-06-03 06:06:47 UTC",
            "allowed_ips": ["1.2.3.4", "3.4.5.6"]
        }
    ]
}

Implementation Reference

• src/didlogic_mcp/tools/sip_accounts.py:8-65 (handler)

  Handler function that executes the list_sip_accounts tool by calling the DidLogic API to retrieve and return a JSON list of all SIP accounts.

  @mcp.tool()
  async def list_sip_accounts(ctx: Context) -> str:
      """
          List all SIP accounts
  
          Returns a JSON object with all SIP accounts where:
              id: ID of SIP account
              name: SIP account name (login)
              callerid: CallerID associated with this SIP account
              label: label fot this SIP account
              charge: charge for calls on this month
              talk_time: total talk time for this month
              rewrite_enabled: do SIP account have calling number rewriting rule
              rewrite_cond: prefix to be rewrited (ex: 00)
              rewrite_prefix: prefix to what should be rewritten (ex: 44)
              didinfo_enabled: do DIDLogic will attempt send DID number as TO when receiving calls to this account
              ip_restrict: do we need to allowlist IP addresses for this account
              allowed_ips: IP addresses allowed for this SIP account
              call_restrict: flag indicates what SIP account should have maximum call time
              call_limit: maximum call duration in seconds
              channels_restrict: flag indicates what SIP account should have maximum channels limit
              max_channels: maximum sip channels
              cost_limit: flag indicates what SIP account should have maximum call cost
              max_call_cost: maximum call cost for this SIP account
              created_at: date of creation this SIP account
  
          Example:
          ```
          {
              "sipaccounts": [
                  {
                      "id": 61,
                      "name": "12345",
                      "callerid": "17254999999",
                      "label": "TEST DEVICE",
                      "host": "dynamic",
                      "charge": "0.0",
                      "talk_time": 0,
                      "rewrite_enabled": false,
                      "rewrite_cond": "8",
                      "rewrite_prefix": "7",
                      "didinfo_enabled": false,
                      "ip_restrict": false,
                      "call_restrict": true,
                      "call_limit": 2800,
                      "channels_restrict": false,
                      "max_channels": 1,
                      "cost_limit": false,
                      "max_call_cost": "5.0",
                      "created_at": "2024-06-03 06:06:47 UTC",
                      "allowed_ips": ["1.2.3.4", "3.4.5.6"]
                  }
              ]
          }
          ```
      """
      response = await base.call_didlogic_api(ctx, "GET", "/v1/sipaccounts")
      return response.text

• src/didlogic_mcp/server.py:100-100 (registration)

  Registration of the sip_accounts tools (including list_sip_accounts) by invoking register_tools on the FastMCP server instance.

  tools.sip_accounts.register_tools(mcp)

• src/didlogic_mcp/tools/base.py:9-53 (helper)

  Shared helper function call_didlogic_api used by the handler to make authenticated HTTP requests to the DidLogic API endpoints.

  async def call_didlogic_api(
      ctx: Context,
      method: str,
      path: str,
      params: Optional[Dict] = None,
      data: Optional[Dict] = None,
      json: Optional[Dict] = None
  ) -> httpx.Response:
      """
      Make a call to the Didlogic API.
  
      In HTTP/SSE mode, extracts Bearer token from request context and adds it
      to the Authorization header for each API call.
      In STDIO mode, uses the API key already configured in the client headers.
      """
      client = ctx.request_context.lifespan_context.client
  
      # In HTTP/SSE mode, get API key from request.state (set by middleware)
      extra_headers = {}
  
      # Check if we have a request object (indicates HTTP/SSE mode)
      request = getattr(ctx.request_context, "request", None)
  
      if request and hasattr(request, 'state') and hasattr(request.state, 'didlogic_api_key'):
          # HTTP/SSE mode: extract API key from request state
          api_key = request.state.didlogic_api_key
          if api_key:
              extra_headers["Authorization"] = f"Bearer {api_key}"
              logger.debug(f"Using API key from request state: {api_key[:8]}...")
          else:
              logger.warning("No API key found in request state")
      else:
          # STDIO mode: API key already in client headers from lifespan
          logger.debug("Using API key from client headers (STDIO mode)")
  
      response = await client.request(
          method=method,
          url=path,
          params=params,
          data=data,
          json=json,
          headers=extra_headers
      )
      response.raise_for_status()
      return response