update_sip_account

Instructions

{
    "sipaccount": {
        "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:277-432 (handler)

  The core handler function for the 'update_sip_account' tool. It uses Pydantic Field for input schema validation, constructs a data dictionary from optional parameters, and performs a PUT request to the Didlogic API endpoint '/v1/sipaccounts/{name}' using the base helper.

  @mcp.tool()
  async def update_sip_account(
      ctx: Context,
      name: str | int = Field(description="SIP Account name"),
      password: Optional[str] = Field(
          description="Password for SIP account", default=None
      ),
      callerid: Optional[str | int] = Field(
          description="Callerid for use with this SIP account", default=None
      ),
      label: Optional[str] = Field(
          description="Label for SIP account", default=None
      ),
      rewrite_enabled: Optional[bool] = Field(
          description="Enable number rewriting for calls", default=None
      ),
      rewrite_cond: Optional[str] = Field(
          description="Prefix to remove from number", default=None
      ),
      rewrite_prefix: Optional[str] = Field(
          description="Prefix to add to number", default=None
      ),
      didinfo_enabled: Optional[bool] = Field(
          description="Enable DID number in inbound calls", default=None
      ),
      ip_restrict: Optional[bool] = Field(
          description="Enable IP restriction for SIP account", default=None
      ),
      call_restrict: Optional[bool] = Field(
          description="Enable call duration limit for SIP account",
          default=None
      ),
      call_limit: Optional[int] = Field(
          description="Maximum call duration for SIP account in seconds",
          default=None
      ),
      channels_restrict: Optional[bool] = Field(
          description="Enable concurrent calls limit", default=None
      ),
      max_channels: Optional[int] = Field(
          description="Count of concurrent calls limit", default=None
      ),
      cost_limit: Optional[bool] = Field(
          description="Enable maximum call cost for SIP account",
          default=None
      ),
      max_call_cost: Optional[float] = Field(
          description="Maximum call cost for SIP account", default=None
      )
  ) -> str:
      """
          Creates a SIP account
  
          Args:
              name: SIP account name
              password: Password to be used for this SIP account
              callerid: CallerID associated with this SIP account
              label: label fot this SIP account
              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
              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
  
  
          Returns a JSON object with SIP account details 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:
          ```
          {
              "sipaccount": {
                  "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"]
              }
          }
          ```
      """
      data = {}
  
      # Add all provided parameters
      if password is not None:
          data["sipaccount[password]"] = password
      if callerid is not None:
          data["sipaccount[callerid]"] = callerid
      if label is not None:
          data["sipaccount[label]"] = label
      if rewrite_enabled is not None:
          data["sipaccount[rewrite_enabled]"] = int(rewrite_enabled)
      if rewrite_cond is not None:
          data["sipaccount[rewrite_cond]"] = rewrite_cond
      if rewrite_prefix is not None:
          data["sipaccount[rewrite_prefix]"] = rewrite_prefix
      if didinfo_enabled is not None:
          data["sipaccount[didinfo_enabled]"] = int(didinfo_enabled)
      if ip_restrict is not None:
          data["sipaccount[ip_restrict]"] = int(ip_restrict)
      if call_restrict is not None:
          data["sipaccount[call_restrict]"] = int(call_restrict)
      if call_limit is not None:
          data["sipaccount[call_limit]"] = call_limit
      if channels_restrict is not None:
          data["sipaccount[channels_restrict]"] = int(channels_restrict)
      if max_channels is not None:
          data["sipaccount[max_channels]"] = max_channels
      if cost_limit is not None:
          data["sipaccount[cost_limit]"] = int(cost_limit)
      if max_call_cost is not None:
          data["sipaccount[max_call_cost]"] = max_call_cost
  
      response = await base.call_didlogic_api(
          ctx, "PUT", f"/v1/sipaccounts/{name}", data=data
      )
      return response.text

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

  Server-wide registration of tool modules, including sip_accounts.register_tools(mcp) which defines and registers the update_sip_account tool via @mcp.tool() decorators.

  tools.balance.register_tools(mcp)
  tools.sip_accounts.register_tools(mcp)
  tools.allowed_ips.register_tools(mcp)
  tools.purchases.register_tools(mcp)
  tools.purchase.register_tools(mcp)
  tools.calls.register_tools(mcp)
  tools.transactions.register_tools(mcp)

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

  Shared helper utility function called by the handler to perform authenticated HTTP requests to the Didlogic API, handling API key from context in both STDIO and HTTP modes.

  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